Merge branch 'master' into compile-time-connectivity-type

src/OpenMesh/Apps/Decimating/CmdOption.hh

@@ -56,7 +56,7 @@ public:
 
   typedef T value_type;
 
-  CmdOption(const T& _val) : val_(_val), valid_(true), enabled_(false) { }
+  explicit CmdOption(const T& _val) : val_(_val), valid_(true), enabled_(false) { }
   CmdOption() : val_(T()),valid_(false), enabled_(false) { }
 
   // has been set and has a value

src/OpenMesh/Apps/Decimating/DecimaterGui/DecimaterGui.pro

@@ -1,24 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-Application()
-
-INCLUDEPATH += ../../..
-
-Application()
-glew()
-glut()
-openmesh()
-
-DIRECTORIES = ../../QtViewer ../
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += ../../QtViewer/QGLViewerWidget.cc ../../QtViewer/MeshViewerWidgetT.cc ../DecimaterViewerWidget.cc
-SOURCES += ../decimaterviewer.cc
-
-
-################################################################################

src/OpenMesh/Apps/Decimating/DecimaterViewerWidget.hh

@@ -123,7 +123,7 @@ public:
 
 
   /// default constructor
-  DecimaterViewerWidget(QWidget* _parent=0)
+  explicit DecimaterViewerWidget(QWidget* _parent=0)
     : MeshViewerWidget(_parent),
       animate_(false),
       timer_(0),

src/OpenMesh/Apps/Decimating/commandlineDecimater/commandlineDecimater.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../..
-
-Application()
-glew()
-glut()
-openmesh()
-
-DIRECTORIES = .. 
-
-# Input
-SOURCES += ../decimater.cc
-
-################################################################################

src/OpenMesh/Apps/QtViewer/MeshViewerWidget.hh

@@ -82,7 +82,7 @@ class MeshViewerWidget : public MeshViewerWidgetT<MyMesh>
     Q_OBJECT
 public:
     /// default constructor
-    MeshViewerWidget(QWidget* parent=0) : MeshViewerWidgetT<MyMesh>(parent)
+    explicit MeshViewerWidget(QWidget* parent=0) : MeshViewerWidgetT<MyMesh>(parent)
     {}
     OpenMesh::IO::Options& options() { return _options; }
     const OpenMesh::IO::Options& options() const { return _options; }

src/OpenMesh/Apps/QtViewer/QtViewer.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-Application()
-glew()
-glut()
-openmesh()
-
-DIRECTORIES = .
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Apps/Smoothing/Smoothing.pro

@@ -1,21 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../..
-
-Application()
-glew()
-glut()
-openmesh()
-
-DIRECTORIES = . 
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Apps/Subdivider/SubdividerGui/SubdividerGui.pro

@@ -1,21 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../..
-
-Application()
-glew()
-glut()
-openmesh()
-
-DIRECTORIES = .. ../../QtViewer
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += ../../QtViewer/QGLViewerWidget.cc ../../QtViewer/MeshViewerWidgetT.cc ../SubdivideWidget.cc
-SOURCES += ../qtsubdivider.cc
-
-################################################################################

src/OpenMesh/Apps/Subdivider/commandlineAdaptiveSubdivider/commandlineAdaptiveSubdivider.pro

@@ -1,15 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../..
-
-Application()
-openmesh()
-
-# Input
-SOURCES += ../adaptive_subdivider.cc
-
-################################################################################

src/OpenMesh/Apps/Subdivider/commandlineSubdivider/commandlineSubdivider.pro

@@ -1,15 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../..
-
-Application()
-openmesh()
-
-# Input
-SOURCES += ../subdivider.cc
-
-################################################################################

src/OpenMesh/Apps/Unsupported/Streaming-qt4/Client/VDPMClientViewerWidget.cc

@@ -139,17 +139,15 @@ void VDPMClientViewerWidget::mesh_coloring()
                       vEnd(mesh_.vertices_end());
 
   VHierarchyNodeHandle  node_handle;
-  float                 ratio;
-  unsigned char         r, g, b;
 
   for (; vIt!=vEnd; ++vIt)
   {
     node_handle = mesh_.data(*vIt).vhierarchy_node_handle();
-    ratio = vhierarchy_.node(node_handle).ratio();
+    const float ratio = vhierarchy_.node(node_handle).ratio();
     
-    r = (unsigned char) ((1.0f - ratio) * myYellow[0] + ratio * myBlue[0]);
-    g = (unsigned char) ((1.0f - ratio) * myYellow[1] + ratio * myBlue[1]);
-    b = (unsigned char) ((1.0f - ratio) * myYellow[2] + ratio * myBlue[2]);
+    const unsigned char r = (unsigned char) ((1.0f - ratio) * myYellow[0] + ratio * myBlue[0]);
+    const unsigned char g = (unsigned char) ((1.0f - ratio) * myYellow[1] + ratio * myBlue[1]);
+    const unsigned char b = (unsigned char) ((1.0f - ratio) * myYellow[2] + ratio * myBlue[2]);
 
     mesh_.set_color(*vIt, OpenMesh::Vec3uc(r,g,b));
   }

src/OpenMesh/Apps/Unsupported/Streaming-qt4/Server/ServerSideVDPM.hh

@@ -77,7 +77,7 @@ private:
 
 public:
 
-  ServerSideVDPM()  { clear(); }
+  ServerSideVDPM() :name_(""),tree_id_bits_(0)  { clear(); }
   void clear();
 
   const char* name() const { return name_; }

src/OpenMesh/Apps/Unsupported/Streaming/Client/VDPMClientViewerWidget.cc

@@ -138,17 +138,15 @@ void VDPMClientViewerWidget::mesh_coloring()
                       vEnd(mesh_.vertices_end());
 
   VHierarchyNodeHandle  node_handle;
-  float                 ratio;
-  unsigned char         r, g, b;
 
   for (; vIt!=vEnd; ++vIt)
   {
     node_handle = mesh_.data(*vIt).vhierarchy_node_handle();
-    ratio = vhierarchy_.node(node_handle).ratio();
+    const float ratio = vhierarchy_.node(node_handle).ratio();
     
-    r = (unsigned char) ((1.0f - ratio) * myYellow[0] + ratio * myBlue[0]);
-    g = (unsigned char) ((1.0f - ratio) * myYellow[1] + ratio * myBlue[1]);
-    b = (unsigned char) ((1.0f - ratio) * myYellow[2] + ratio * myBlue[2]);
+    const unsigned char r = (unsigned char) ((1.0f - ratio) * myYellow[0] + ratio * myBlue[0]);
+    const unsigned char g = (unsigned char) ((1.0f - ratio) * myYellow[1] + ratio * myBlue[1]);
+    const unsigned char b = (unsigned char) ((1.0f - ratio) * myYellow[2] + ratio * myBlue[2]);
 
     mesh_.set_color(*vIt, OpenMesh::Vec3uc(r,g,b));
   }

src/OpenMesh/Apps/Unsupported/Streaming/Server/ServerSideVDPM.hh

@@ -76,7 +76,7 @@ private:
 
 public:
 
-  ServerSideVDPM()  { clear(); }
+  ServerSideVDPM(): name_(""),tree_id_bits_(0)  { clear(); }
   void clear();
 
   const char* name() const { return name_; }

src/OpenMesh/Apps/VDProgMesh/Analyzer/Analyzer.pro

@@ -1,26 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../../..
-
-CONFIG += glew glut
-
-Application()
-
-LIBS         += -Wl,-rpath=$${TOPDIR}/OpenMesh/Core/lib/$${BUILDDIRECTORY} -lCore
-LIBS         += -Wl,-rpath=$${TOPDIR}/OpenMesh/Tools/lib/$${BUILDDIRECTORY} -lTools
-LIBS 	     += -lglut
-QMAKE_LIBDIR += $${TOPDIR}/OpenMesh/Core/lib/$${BUILDDIRECTORY}
-QMAKE_LIBDIR += $${TOPDIR}/OpenMesh/Tools/lib/$${BUILDDIRECTORY}
-
-DIRECTORIES = .
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Apps/VDProgMesh/Synthesizer/Synthesizer.pro

@@ -1,27 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../../..
-
-CONFIG += glew glut
-
-Application()
-
-LIBS         += -Wl,-rpath=$${TOPDIR}/OpenMesh/Core/lib/$${BUILDDIRECTORY} -lCore
-LIBS         += -Wl,-rpath=$${TOPDIR}/OpenMesh/Tools/lib/$${BUILDDIRECTORY} -lTools
-LIBS 	     += -lglut
-QMAKE_LIBDIR += $${TOPDIR}/OpenMesh/Core/lib/$${BUILDDIRECTORY}
-QMAKE_LIBDIR += $${TOPDIR}/OpenMesh/Tools/lib/$${BUILDDIRECTORY}
-
-DIRECTORIES = . ../../QtViewer
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-SOURCES -= ../../QtViewer/meshviewer.cc
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Apps/VDProgMesh/mkbalancedpm/mkbalancedpm.cc

@@ -89,7 +89,7 @@ public:
 public:
 
    /// Constructor
-  ModBalancerT( D &_dec )
+  explicit ModBalancerT( D &_dec )
     : BaseModQ( _dec ),
       max_level_(0), n_roots_(0), n_vertices_(0)
   {

src/OpenMesh/Apps/VDProgMesh/mkbalancedpm/mkbalancedpm.pro

@@ -1,26 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-INCLUDEPATH += ../../../..
-
-CONFIG += glew glut
-
-Application()
-
-LIBS         += -Wl,-rpath=$${TOPDIR}/OpenMesh/Core/lib/$${BUILDDIRECTORY} -lCore
-LIBS         += -Wl,-rpath=$${TOPDIR}/OpenMesh/Tools/lib/$${BUILDDIRECTORY} -lTools
-LIBS 	     += -lglut
-QMAKE_LIBDIR += $${TOPDIR}/OpenMesh/Core/lib/$${BUILDDIRECTORY}
-QMAKE_LIBDIR += $${TOPDIR}/OpenMesh/Tools/lib/$${BUILDDIRECTORY}
-
-DIRECTORIES = .
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Apps/mconvert/mconvert.pro

@@ -1,22 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-Application()
-
-INCLUDEPATH += ../../..
-
-glew()
-glut()
-openmesh()
-
-DIRECTORIES = .
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Core/Core.pro

@@ -1,43 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-Library()
-
-contains( OPENFLIPPER , OpenFlipper ){
-	DESTDIR = $${TOPDIR}/OpenMesh/lib
-} else {
-	DESTDIR = $${TOPDIR}/lib
-}
-
-
-DIRECTORIES = . Geometry IO IO/exporter IO/importer IO/reader IO/writer \
-		Mesh Mesh/gen System Utils
-
-INCLUDEPATH += ../..
-
-CONFIG( debug, debug|release ){
-        TARGET    = OpenMeshCored
-} else {
-	TARGET    = OpenMeshCore
-}
-
-win32 {
- DEFINES += _USE_MATH_DEFINES NOMINMAX
- CONFIG  += static
-}
-
-macx {
-      # Set library binary header to the correct path
-      QMAKE_LFLAGS_SONAME = -install_name$${LITERAL_WHITESPACE}$${DESTDIR}/
-      export(QMAKE_LFLAGS_SONAME)
-}
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc)
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-################################################################################

src/OpenMesh/Core/Geometry/Vector11T.hh

@@ -718,6 +718,47 @@ noexcept(noexcept(_v1.swap(_v2))) {
     _v1.swap(_v2);
 }
 
+/// \relates OpenMesh::VectorT
+/// non-member norm
+template<typename Scalar, int DIM>
+Scalar norm(const VectorT<Scalar, DIM>& _v) {
+    return _v.norm();
+}
+
+/// \relates OpenMesh::VectorT
+/// non-member sqrnorm
+template<typename Scalar, int DIM>
+Scalar sqrnorm(const VectorT<Scalar, DIM>& _v) {
+    return _v.sqrnorm();
+}
+/// \relates OpenMesh::VectorT
+/// non-member vectorize
+template<typename Scalar, int DIM, typename OtherScalar>
+VectorT<Scalar, DIM>& vectorize(VectorT<Scalar, DIM>& _v, OtherScalar const& _val) {
+    return _v.vectorize(_val);
+}
+
+/// \relates OpenMesh::VectorT
+/// non-member normalize
+template<typename Scalar, int DIM>
+VectorT<Scalar, DIM>& normalize(VectorT<Scalar, DIM>& _v) {
+    return _v.normalize();
+}
+
+/// \relates OpenMesh::VectorT
+/// non-member maximize
+template<typename Scalar, int DIM>
+VectorT<Scalar, DIM>& maximize(VectorT<Scalar, DIM>& _v1, VectorT<Scalar, DIM>& _v2) {
+    return _v1.maximize(_v2);
+}
+
+/// \relates OpenMesh::VectorT
+/// non-member minimize
+template<typename Scalar, int DIM>
+VectorT<Scalar, DIM>& minimize(VectorT<Scalar, DIM>& _v1, VectorT<Scalar, DIM>& _v2) {
+    return _v1.minimize(_v2);
+}
+
 //== TYPEDEFS =================================================================
 
 /** 1-byte signed vector */

src/OpenMesh/Core/Geometry/VectorT.hh

@@ -274,6 +274,52 @@ cross(const VectorT<Scalar,N>& _v1, const VectorT<Scalar,N>& _v2) {
 }
 
 
+/// \relates OpenMesh::VectorT
+/// non-member norm
+template<typename Scalar, int DIM>
+Scalar norm(const VectorT<Scalar, DIM>& _v) {
+    return _v.norm();
+}
+
+
+/// \relates OpenMesh::VectorT
+/// non-member sqrnorm
+template<typename Scalar, int DIM>
+Scalar sqrnorm(const VectorT<Scalar, DIM>& _v) {
+    return _v.sqrnorm();
+}
+
+
+/// \relates OpenMesh::VectorT
+/// non-member vectorize
+template<typename Scalar, int DIM, typename OtherScalar>
+VectorT<Scalar, DIM>& vectorize(VectorT<Scalar, DIM>& _v, OtherScalar const& _val) {
+    return _v.vectorize(_val);
+}
+
+
+/// \relates OpenMesh::VectorT
+/// non-member normalize
+template<typename Scalar, int DIM>
+VectorT<Scalar, DIM>& normalize(VectorT<Scalar, DIM>& _v) {
+    return _v.normalize();
+}
+
+
+/// \relates OpenMesh::VectorT
+/// non-member maximize
+template<typename Scalar, int DIM>
+VectorT<Scalar, DIM>& maximize(VectorT<Scalar, DIM>& _v1, VectorT<Scalar, DIM>& _v2) {
+    return _v1.maximize(_v2);
+}
+
+
+/// \relates OpenMesh::VectorT
+/// non-member minimize
+template<typename Scalar, int DIM>
+VectorT<Scalar, DIM>& minimize(VectorT<Scalar, DIM>& _v1, VectorT<Scalar, DIM>& _v2) {
+    return _v1.minimize(_v2);
+}
 
 
 //== TYPEDEFS =================================================================

src/OpenMesh/Core/IO/MeshIO.hh

@@ -55,11 +55,24 @@
 
 // -------------------- system settings
 #include <OpenMesh/Core/System/config.h>
+
 // -------------------- check include order
 #if defined (OPENMESH_TRIMESH_ARRAY_KERNEL_HH) || \
     defined (OPENMESH_POLYMESH_ARRAY_KERNEL_HH)
-#  error "Include MeshIO.hh before including a mesh type!"
+
+    // Issue warning if MeshIO was not included before Mesh Type
+    // Nobody knows why this order was enforced.
+    // If somebody encounters an error resulting from a wrong order, please report it to the OpenMesh developers.
+    // If we don't here about any errors, this check will be removed
+    // @TODO: Remove after reasonable time
+    #ifdef WIN32
+      #pragma message("MeshIO.hh was included after Mesh Type. You may ignore this warning. Please report errors resulting ifrom this order to the developers!")
+    #else
+      #warning "MeshIO.hh was included after Mesh Type. You may ignore this warning. Please report errors resulting from this order to the developers!"
+    #endif
+
 #endif
+
 // -------------------- OpenMesh
 #include <OpenMesh/Core/IO/SR_store.hh>
 #include <OpenMesh/Core/IO/IOManager.hh>

src/OpenMesh/Core/IO/OMFormat.hh

@@ -315,16 +315,16 @@ namespace OMFormat {
   /// Return the size of chunk data in bytes
   inline size_t chunk_data_size( Header& _hdr,  Chunk::Header& _chunk_hdr )
   {
-    size_t C     = 0;
-
+    size_t C;
     switch( _chunk_hdr.entity_ )
     {
       case Chunk::Entity_Vertex:   C  = _hdr.n_vertices_; break;
       case Chunk::Entity_Face:     C  = _hdr.n_faces_;    break;
-      case Chunk::Entity_Halfedge: C  = _hdr.n_edges_;    // no break!
-      case Chunk::Entity_Edge:     C += _hdr.n_edges_;    break;
+      case Chunk::Entity_Halfedge: C  = _hdr.n_edges_*2;  break;
+      case Chunk::Entity_Edge:     C  = _hdr.n_edges_;    break;
       case Chunk::Entity_Mesh:     C  = 1;                break;
       default:
+        C = 0;
         std::cerr << "Invalid value in _chunk_hdr.entity_\n";
         assert( false );
         break;

src/OpenMesh/Core/IO/OMFormatT.cc

@@ -145,7 +145,7 @@ namespace IO {
   }
 
 
-  // helper to store a an integer
+  // helper to restore a an integer
   template< typename T > 
   size_t 
   restore( std::istream& _is, 
@@ -171,25 +171,28 @@ namespace IO {
 	OMFormat::int16 v;
 	bytes = restore( _is, v, _swap );
 	_val = static_cast<T>(v);
+	break;
       }
       case OMFormat::Chunk::Integer_32:
       { 
 	OMFormat::int32 v;
 	bytes = restore( _is, v, _swap );
 	_val = static_cast<T>(v);
+	break;
       }      
       case OMFormat::Chunk::Integer_64:
       { 
 	OMFormat::int64 v;
 	bytes = restore( _is, v, _swap );
 	_val = static_cast<T>(v);
+	break;
       }
     }
     return bytes;
   }
 
 
-  // helper to store a an unsigned integer
+  // helper to restore a an unsigned integer
   template< typename T > 
   size_t 
   restore( std::istream& _is, 

src/OpenMesh/Core/IO/reader/BaseReader.hh

@@ -156,7 +156,16 @@ protected:
  * @return trimmed string
  */
 static inline std::string &left_trim(std::string &_string) {
-  _string.erase(_string.begin(), std::find_if(_string.begin(), _string.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
+
+  // Find out if the compiler supports CXX11
+  #if ( __cplusplus >= 201103L || _MSVC_LANG >= 201103L )
+    // as with CXX11 we can use lambda expressions
+    _string.erase(_string.begin(), std::find_if(_string.begin(), _string.end(), [](int i)->int { return ! std::isspace(i); }));
+  #else
+    // we do what we did before
+    _string.erase(_string.begin(), std::find_if(_string.begin(), _string.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
+  #endif
+  
   return _string;
 }
 
@@ -168,7 +177,18 @@ static inline std::string &left_trim(std::string &_string) {
  * @return trimmed string
  */
 static inline std::string &right_trim(std::string &_string) {
-  _string.erase(std::find_if(_string.rbegin(), _string.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), _string.end());
+
+  // Find out if the compiler supports CXX11
+  #if ( __cplusplus >= 201103L || _MSVC_LANG >= 201103L )
+    // as with CXX11 we can use lambda expressions
+    _string.erase(std::find_if(_string.rbegin(), _string.rend(), [](int i)->int { return ! std::isspace(i); } ).base(), _string.end());
+  #else
+    // we do what we did before
+    _string.erase(std::find_if(_string.rbegin(), _string.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), _string.end());
+  #endif
+
+
+
   return _string;
 }
 

src/OpenMesh/Core/IO/reader/OBJReader.cc

@@ -540,6 +540,7 @@ read(std::istream& _in, BaseImporter& _bi, Options& _opt)
 
       vhandles.clear();
       face_texcoords.clear();
+      face_texcoords3d.clear();
 
       // read full line after detecting a face
       std::string faceLine;

src/OpenMesh/Core/IO/reader/PLYReader.cc

@@ -1062,7 +1062,7 @@ std::string get_property_name(std::string _string1, std::string _string2) {
 
 //-----------------------------------------------------------------------------
 
-_PLYReader_::ValueType get_property_type(std::string _string1, std::string _string2) {
+_PLYReader_::ValueType get_property_type(std::string& _string1, std::string& _string2) {
 
     if (_string1 == "float32" || _string2 == "float32")
 
@@ -1270,6 +1270,8 @@ bool _PLYReader_::can_u_read(std::istream& _is) const {
 						omerr() << "Custom face Properties defined, before 'vertex_indices' property was defined. They will be skipped" << std::endl;
 						elements_.back().properties_.clear();
 					}
+                  } else {
+                      options_ += Options::Custom;
                   }
 
                 }

src/OpenMesh/Core/IO/reader/STLReader.cc

@@ -176,7 +176,7 @@ class CmpVec
 {
 public:
 
-  CmpVec(float _eps=FLT_MIN) : eps_(_eps) {}
+  explicit CmpVec(float _eps=FLT_MIN) : eps_(_eps) {}
 
   bool operator()( const Vec3f& _v0, const Vec3f& _v1 ) const
   {

src/OpenMesh/Core/IO/writer/OBJWriter.cc

@@ -224,12 +224,22 @@ write(std::ostream& _out, BaseExporter& _be, Options _opt, std::streamsize _prec
   if (!check( _be, _opt))
      return false;
 
+  // No binary mode for OBJ
+  if ( _opt.check(Options::Binary) ) {
+    omout() << "[OBJWriter] : Warning, Binary mode requested for OBJ Writer (No support for Binary mode), falling back to standard." <<  std::endl;
+  }
 
-  // check writer features
-  if ( _opt.check(Options::Binary)     || // not supported by format
-       _opt.check(Options::FaceNormal))
-     return false;
+  // check for unsupported writer features
+  if (_opt.check(Options::FaceNormal) ) {
+    omerr() << "[OBJWriter] : FaceNormal not supported by OBJ Writer" <<  std::endl;
+    return false;
+  }
 
+  // check for unsupported writer features
+  if (_opt.check(Options::VertexColor) ) {
+    omerr() << "[OBJWriter] : VertexColor not supported by OBJ Writer" <<  std::endl;
+    return false;
+  }
 
   //create material file if needed
   if ( _opt.check(Options::FaceColor) ){
@@ -270,10 +280,10 @@ write(std::ostream& _out, BaseExporter& _be, Options _opt, std::streamsize _prec
     }
   }
 
-  //collect Texturevertices from vertices
+  //collect Texture coordinates from vertices
   if(_opt.check(Options::VertexTexCoord))
   {
-    for (size_t i=0, nF=_be.n_faces(); i<nF; ++i)
+    for (size_t i=0, nV=_be.n_vertices(); i<nV; ++i)
     {
       vh = VertexHandle(static_cast<int>(i));
       t  = _be.texcoord(vh);
@@ -363,7 +373,7 @@ write(std::ostream& _out, BaseExporter& _be, Options _opt, std::streamsize _prec
         {
           // write vertex texture coordinate index
           if (_opt.check(Options::VertexTexCoord))
-            _out  << texMap[_be.texcoord(vh)];
+            _out  << texMap[_be.texcoord(vhandles[j])];
         }
 
         // write vertex normal index

src/OpenMesh/Core/IO/writer/OMWriter.cc

@@ -163,7 +163,7 @@ _OMWriter_::write(std::ostream& _os, BaseExporter& _be, Options _opt, std::strea
 #ifndef DOXY_IGNORE_THIS
 template <typename T> struct Enabler
 {
-  Enabler( T& obj ) : obj_(obj)
+  explicit Enabler( T& obj ) : obj_(obj)
   {}
 
   ~Enabler() { obj_.enable(); }
@@ -302,7 +302,8 @@ bool _OMWriter_::write_binary(std::ostream& _os, BaseExporter& _be,
 
     for (i=0, nF=header.n_faces_; i<nF; ++i)
     {
-      nV = _be.get_vhandles(FaceHandle(i), vhandles);
+      //nV = _be.get_vhandles(FaceHandle(i), vhandles);
+      _be.get_vhandles(FaceHandle(i), vhandles);
       if ( header.mesh_ == 'P' )
         bytes += store( _os, vhandles.size(), OMFormat::Chunk::Integer_16, swap );
 

src/OpenMesh/Core/IO/writer/STLWriter.cc

@@ -158,7 +158,7 @@ write_stla(const std::string& _filename, BaseExporter& _be, Options /* _opt */)
 
 
 
-  int i, nF(int(_be.n_faces())), nV;
+  int i, nF(int(_be.n_faces()));
   Vec3f  a, b, c, n;
   std::vector<VertexHandle> vhandles;
   FaceHandle fh;
@@ -172,7 +172,7 @@ write_stla(const std::string& _filename, BaseExporter& _be, Options /* _opt */)
   for (i=0; i<nF; ++i)
   {
     fh = FaceHandle(i);
-    nV = _be.get_vhandles(fh, vhandles);
+    const int nV = _be.get_vhandles(fh, vhandles);
 
     if (nV == 3)
     {
@@ -211,7 +211,7 @@ write_stla(std::ostream& _out, BaseExporter& _be, Options /* _opt */, std::strea
 {
   omlog() << "[STLWriter] : write ascii file\n";
 
-  int i, nF(int(_be.n_faces())), nV;
+  int i, nF(int(_be.n_faces()));
   Vec3f  a, b, c, n;
   std::vector<VertexHandle> vhandles;
   FaceHandle fh;
@@ -226,7 +226,7 @@ write_stla(std::ostream& _out, BaseExporter& _be, Options /* _opt */, std::strea
   for (i=0; i<nF; ++i)
   {
     fh = FaceHandle(i);
-    nV = _be.get_vhandles(fh, vhandles);
+    const int nV = _be.get_vhandles(fh, vhandles);
 
     if (nV == 3)
     {
@@ -273,7 +273,7 @@ write_stlb(const std::string& _filename, BaseExporter& _be, Options /* _opt */)
   }
 
 
-  int i, nF(int(_be.n_faces())), nV;
+  int i, nF(int(_be.n_faces()));
   Vec3f  a, b, c, n;
   std::vector<VertexHandle> vhandles;
   FaceHandle fh;
@@ -294,7 +294,7 @@ write_stlb(const std::string& _filename, BaseExporter& _be, Options /* _opt */)
   for (i=0; i<nF; ++i)
   {
     fh = FaceHandle(i);
-    nV = _be.get_vhandles(fh, vhandles);
+    const int nV = _be.get_vhandles(fh, vhandles);
 
     if (nV == 3)
     {
@@ -344,7 +344,7 @@ write_stlb(std::ostream& _out, BaseExporter& _be, Options /* _opt */, std::strea
   omlog() << "[STLWriter] : write binary file\n";
 
 
-  int i, nF(int(_be.n_faces())), nV;
+  int i, nF(int(_be.n_faces()));
   Vec3f  a, b, c, n;
   std::vector<VertexHandle> vhandles;
   FaceHandle fh;
@@ -366,7 +366,7 @@ write_stlb(std::ostream& _out, BaseExporter& _be, Options /* _opt */, std::strea
   for (i=0; i<nF; ++i)
   {
     fh = FaceHandle(i);
-    nV = _be.get_vhandles(fh, vhandles);
+    const int nV = _be.get_vhandles(fh, vhandles);
 
     if (nV == 3)
     {

src/OpenMesh/Core/Mesh/ArrayKernel.cc

@@ -37,146 +37,145 @@
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
  *                                                                           *
- * ========================================================================= */
-
-/*===========================================================================*\
- *                                                                           *             
- *   $Revision$                                                         *
- *   $Date$                   *
- *                                                                           *
-\*===========================================================================*/
-
-#include <OpenMesh/Core/Mesh/ArrayKernel.hh>
-
-namespace OpenMesh
-{
-
-ArrayKernel::ArrayKernel()
-: refcount_vstatus_(0), refcount_hstatus_(0),
-  refcount_estatus_(0), refcount_fstatus_(0)
-{
-  init_bit_masks(); //Status bit masks initialization
-}
-
-ArrayKernel::~ArrayKernel()
-{
-  clear();
-}
-
-// ArrayKernel::ArrayKernel(const ArrayKernel& _rhs)
-// : BaseKernel(_rhs),
-//   vertices_(_rhs.vertices_), edges_(_rhs.edges_), faces_(_rhs.faces_),
-//   vertex_status_(_rhs.vertex_status_), halfedge_status_(_rhs.halfedge_status_),
-//   edge_status_(_rhs.edge_status_), face_status_(_rhs.face_status_),
-//   refcount_vstatus_(_rhs.refcount_vstatus_), refcount_hstatus_(_rhs.refcount_hstatus_),
-//   refcount_estatus_(_rhs.refcount_estatus_), refcount_fstatus_(_rhs.refcount_fstatus_)
-// {}
-
-
-void ArrayKernel::assign_connectivity(const ArrayKernel& _other)
-{
-  vertices_ = _other.vertices_;
-  edges_ = _other.edges_;
-  faces_ = _other.faces_;
-  
-  vprops_resize(n_vertices());
-  hprops_resize(n_halfedges());
-  eprops_resize(n_edges());
-  fprops_resize(n_faces());
-  
-#define COPY_STATUS_PROPERTY(ENTITY) \
-  if (_other.ENTITY##_status_.is_valid()) \
-  {   \
-    if (!ENTITY##_status_.is_valid()) \
-    { \
-      request_##ENTITY##_status(); \
-    } \
-    property(ENTITY##_status_) = _other.property(_other.ENTITY##_status_); \
-  }
-  COPY_STATUS_PROPERTY(vertex)
-  COPY_STATUS_PROPERTY(halfedge)
-  COPY_STATUS_PROPERTY(edge)
-  COPY_STATUS_PROPERTY(face)
-  
-#undef COPY_STATUS_PROPERTY
-}
-
-// --- handle -> item ---
-VertexHandle ArrayKernel::handle(const Vertex& _v) const
-{
-   return VertexHandle( int( &_v - &vertices_.front()));
-}
-
-HalfedgeHandle ArrayKernel::handle(const Halfedge& _he) const
-{
-  // Calculate edge belonging to given halfedge
-  // There are two halfedges stored per edge
-  // Get memory position inside edge vector and devide by size of an edge
-  // to get the corresponding edge for the requested halfedge
-  size_t eh = ( (char*)&_he - (char*)&edges_.front() ) /  sizeof(Edge)  ;
-  assert((&_he == &edges_[eh].halfedges_[0]) ||
-         (&_he == &edges_[eh].halfedges_[1]));
-  return ((&_he == &edges_[eh].halfedges_[0]) ?
-                    HalfedgeHandle( int(eh)<<1) : HalfedgeHandle((int(eh)<<1)+1));
-}
-
-EdgeHandle ArrayKernel::handle(const Edge& _e) const
-{
-  return EdgeHandle( int(&_e - &edges_.front() ) );
-}
-
-FaceHandle ArrayKernel::handle(const Face& _f) const
-{
-  return FaceHandle( int(&_f - &faces_.front()) );
-}
-
-#define SIGNED(x) signed( (x) )
-
-bool ArrayKernel::is_valid_handle(VertexHandle _vh) const
-{
-  return 0 <= _vh.idx() && _vh.idx() < SIGNED(n_vertices());
-}
-
-bool ArrayKernel::is_valid_handle(HalfedgeHandle _heh) const
-{
-  return 0 <= _heh.idx() && _heh.idx() < SIGNED(n_edges()*2);
-}
-
-bool ArrayKernel::is_valid_handle(EdgeHandle _eh) const
-{
-  return 0 <= _eh.idx() && _eh.idx() < SIGNED(n_edges());
-}
-
-bool ArrayKernel::is_valid_handle(FaceHandle _fh) const
-{
-  return 0 <= _fh.idx() && _fh.idx() < SIGNED(n_faces());
-}
-
-#undef SIGNED
-
-unsigned int ArrayKernel::delete_isolated_vertices()
-{
-  assert(has_vertex_status());//this function requires vertex status property
-  unsigned int n_isolated = 0;
-  for (KernelVertexIter v_it = vertices_begin(); v_it != vertices_end(); ++v_it)
-  {
-    if (is_isolated(handle(*v_it)))
-    {
-      status(handle(*v_it)).set_deleted(true);
-      n_isolated++;
-    }
-  }
-  return n_isolated;
-}
-
-void ArrayKernel::garbage_collection(bool _v, bool _e, bool _f)
-{
-  std::vector<VertexHandle*> empty_vh;
-  std::vector<HalfedgeHandle*> empty_hh;
-  std::vector<FaceHandle*> empty_fh;
-  garbage_collection( empty_vh,empty_hh,empty_fh,_v, _e, _f);
-}
-
+ * ========================================================================= */
+
+/*===========================================================================*\
+ *                                                                           *             
+ *   $Revision$                                                         *
+ *   $Date$                   *
+ *                                                                           *
+\*===========================================================================*/
+
+#include <OpenMesh/Core/Mesh/ArrayKernel.hh>
+
+namespace OpenMesh
+{
+
+ArrayKernel::ArrayKernel()
+: refcount_vstatus_(0), refcount_hstatus_(0),
+  refcount_estatus_(0), refcount_fstatus_(0)
+{
+  init_bit_masks(); //Status bit masks initialization
+}
+
+ArrayKernel::~ArrayKernel()
+{
+  clear();
+}
+
+// ArrayKernel::ArrayKernel(const ArrayKernel& _rhs)
+// : BaseKernel(_rhs),
+//   vertices_(_rhs.vertices_), edges_(_rhs.edges_), faces_(_rhs.faces_),
+//   vertex_status_(_rhs.vertex_status_), halfedge_status_(_rhs.halfedge_status_),
+//   edge_status_(_rhs.edge_status_), face_status_(_rhs.face_status_),
+//   refcount_vstatus_(_rhs.refcount_vstatus_), refcount_hstatus_(_rhs.refcount_hstatus_),
+//   refcount_estatus_(_rhs.refcount_estatus_), refcount_fstatus_(_rhs.refcount_fstatus_)
+// {}
+
+
+void ArrayKernel::assign_connectivity(const ArrayKernel& _other)
+{
+  vertices_ = _other.vertices_;
+  edges_ = _other.edges_;
+  faces_ = _other.faces_;
+  
+  vprops_resize(n_vertices());
+  hprops_resize(n_halfedges());
+  eprops_resize(n_edges());
+  fprops_resize(n_faces());
+  
+  //just copy status properties for now,
+  //until a proper solution for refcounted
+  //properties is available
+  vertex_status_ = _other.vertex_status_;
+  halfedge_status_ = _other.halfedge_status_;
+  edge_status_ = _other.edge_status_;
+  face_status_ = _other.face_status_;
+
+  //initialize refcounter to 1 for the new mesh, 
+  //if status is available.
+  refcount_estatus_ = _other.refcount_estatus_ > 0 ? 1 : 0;
+  refcount_vstatus_ = _other.refcount_vstatus_ > 0 ? 1 : 0;
+  refcount_hstatus_ = _other.refcount_hstatus_ > 0 ? 1 : 0;
+  refcount_fstatus_ = _other.refcount_fstatus_ > 0 ? 1 : 0;
+}
+
+// --- handle -> item ---
+VertexHandle ArrayKernel::handle(const Vertex& _v) const
+{
+   return VertexHandle( int( &_v - &vertices_.front()));
+}
+
+HalfedgeHandle ArrayKernel::handle(const Halfedge& _he) const
+{
+  // Calculate edge belonging to given halfedge
+  // There are two halfedges stored per edge
+  // Get memory position inside edge vector and devide by size of an edge
+  // to get the corresponding edge for the requested halfedge
+  size_t eh = ( (char*)&_he - (char*)&edges_.front() ) /  sizeof(Edge)  ;
+  assert((&_he == &edges_[eh].halfedges_[0]) ||
+         (&_he == &edges_[eh].halfedges_[1]));
+  return ((&_he == &edges_[eh].halfedges_[0]) ?
+                    HalfedgeHandle( int(eh)<<1) : HalfedgeHandle((int(eh)<<1)+1));
+}
+
+EdgeHandle ArrayKernel::handle(const Edge& _e) const
+{
+  return EdgeHandle( int(&_e - &edges_.front() ) );
+}
+
+FaceHandle ArrayKernel::handle(const Face& _f) const
+{
+  return FaceHandle( int(&_f - &faces_.front()) );
+}
+
+#define SIGNED(x) signed( (x) )
+
+bool ArrayKernel::is_valid_handle(VertexHandle _vh) const
+{
+  return 0 <= _vh.idx() && _vh.idx() < SIGNED(n_vertices());
+}
+
+bool ArrayKernel::is_valid_handle(HalfedgeHandle _heh) const
+{
+  return 0 <= _heh.idx() && _heh.idx() < SIGNED(n_edges()*2);
+}
+
+bool ArrayKernel::is_valid_handle(EdgeHandle _eh) const
+{
+  return 0 <= _eh.idx() && _eh.idx() < SIGNED(n_edges());
+}
+
+bool ArrayKernel::is_valid_handle(FaceHandle _fh) const
+{
+  return 0 <= _fh.idx() && _fh.idx() < SIGNED(n_faces());
+}
+
+#undef SIGNED
+
+unsigned int ArrayKernel::delete_isolated_vertices()
+{
+  assert(has_vertex_status());//this function requires vertex status property
+  unsigned int n_isolated = 0;
+  for (KernelVertexIter v_it = vertices_begin(); v_it != vertices_end(); ++v_it)
+  {
+    if (is_isolated(handle(*v_it)))
+    {
+      status(handle(*v_it)).set_deleted(true);
+      n_isolated++;
+    }
+  }
+  return n_isolated;
+}
+
+void ArrayKernel::garbage_collection(bool _v, bool _e, bool _f)
+{
+  std::vector<VertexHandle*> empty_vh;
+  std::vector<HalfedgeHandle*> empty_hh;
+  std::vector<FaceHandle*> empty_fh;
+  garbage_collection( empty_vh,empty_hh,empty_fh,_v, _e, _f);
+}
+
 void ArrayKernel::clean_keep_reservation()
 {
     vertices_.clear();
@@ -187,74 +186,74 @@ void ArrayKernel::clean_keep_reservation()
 
 }
 
-void ArrayKernel::clean()
-{
-
-  vertices_.clear();
-  VertexContainer().swap( vertices_ );
-
-  edges_.clear();
-  EdgeContainer().swap( edges_ );
-
-  faces_.clear();
-  FaceContainer().swap( faces_ );
-
-}
-
-
-void ArrayKernel::clear()
-{
-  vprops_clear();
-  eprops_clear();
-  hprops_clear();
-  fprops_clear();
-
-  clean();
-}
-
-
-
-void ArrayKernel::resize( size_t _n_vertices, size_t _n_edges, size_t _n_faces )
-{
-  vertices_.resize(_n_vertices);
-  edges_.resize(_n_edges);
-  faces_.resize(_n_faces);
-
-  vprops_resize(n_vertices());
-  hprops_resize(n_halfedges());
-  eprops_resize(n_edges());
-  fprops_resize(n_faces());
-}
-
-void ArrayKernel::reserve(size_t _n_vertices, size_t _n_edges, size_t _n_faces )
-{
-  vertices_.reserve(_n_vertices);
-  edges_.reserve(_n_edges);
-  faces_.reserve(_n_faces);
-
-  vprops_reserve(_n_vertices);
-  hprops_reserve(_n_edges*2);
-  eprops_reserve(_n_edges);
-  fprops_reserve(_n_faces);
-}
-
-// Status Sets API
-void ArrayKernel::init_bit_masks(BitMaskContainer& _bmc)
-{
-  for (unsigned int i = Attributes::UNUSED; i != 0; i <<= 1)
-  {
-    _bmc.push_back(i);
-  }
-}
-
-void ArrayKernel::init_bit_masks()
-{
-  init_bit_masks(vertex_bit_masks_);
-  edge_bit_masks_ = vertex_bit_masks_;//init_bit_masks(edge_bit_masks_);
-  face_bit_masks_ = vertex_bit_masks_;//init_bit_masks(face_bit_masks_);
-  halfedge_bit_masks_= vertex_bit_masks_;//init_bit_masks(halfedge_bit_masks_);
-}
-
-
-};
-
+void ArrayKernel::clean()
+{
+
+  vertices_.clear();
+  VertexContainer().swap( vertices_ );
+
+  edges_.clear();
+  EdgeContainer().swap( edges_ );
+
+  faces_.clear();
+  FaceContainer().swap( faces_ );
+
+}
+
+
+void ArrayKernel::clear()
+{
+  vprops_clear();
+  eprops_clear();
+  hprops_clear();
+  fprops_clear();
+
+  clean();
+}
+
+
+
+void ArrayKernel::resize( size_t _n_vertices, size_t _n_edges, size_t _n_faces )
+{
+  vertices_.resize(_n_vertices);
+  edges_.resize(_n_edges);
+  faces_.resize(_n_faces);
+
+  vprops_resize(n_vertices());
+  hprops_resize(n_halfedges());
+  eprops_resize(n_edges());
+  fprops_resize(n_faces());
+}
+
+void ArrayKernel::reserve(size_t _n_vertices, size_t _n_edges, size_t _n_faces )
+{
+  vertices_.reserve(_n_vertices);
+  edges_.reserve(_n_edges);
+  faces_.reserve(_n_faces);
+
+  vprops_reserve(_n_vertices);
+  hprops_reserve(_n_edges*2);
+  eprops_reserve(_n_edges);
+  fprops_reserve(_n_faces);
+}
+
+// Status Sets API
+void ArrayKernel::init_bit_masks(BitMaskContainer& _bmc)
+{
+  for (unsigned int i = Attributes::UNUSED; i != 0; i <<= 1)
+  {
+    _bmc.push_back(i);
+  }
+}
+
+void ArrayKernel::init_bit_masks()
+{
+  init_bit_masks(vertex_bit_masks_);
+  edge_bit_masks_ = vertex_bit_masks_;//init_bit_masks(edge_bit_masks_);
+  face_bit_masks_ = vertex_bit_masks_;//init_bit_masks(face_bit_masks_);
+  halfedge_bit_masks_= vertex_bit_masks_;//init_bit_masks(halfedge_bit_masks_);
+}
+
+
+};
+

src/OpenMesh/Core/Mesh/ArrayKernel.hh

@@ -879,10 +879,7 @@ private:
   void                                      init_bit_masks(BitMaskContainer& _bmc);
   void                                      init_bit_masks();
 
-private:
-  VertexContainer                           vertices_;
-  EdgeContainer                             edges_;
-  FaceContainer                             faces_;
+protected:
 
   VertexStatusPropertyHandle                vertex_status_;
   HalfedgeStatusPropertyHandle              halfedge_status_;
@@ -894,6 +891,11 @@ private:
   unsigned int                              refcount_estatus_;
   unsigned int                              refcount_fstatus_;
 
+private:
+  VertexContainer                           vertices_;
+  EdgeContainer                             edges_;
+  FaceContainer                             faces_;
+
   BitMaskContainer                          halfedge_bit_masks_;
   BitMaskContainer                          edge_bit_masks_;
   BitMaskContainer                          vertex_bit_masks_;

src/OpenMesh/Core/Mesh/AttribKernelT.hh

@@ -744,48 +744,34 @@ private:
       {
           //mesh has no points?
       }
-      if(this->get_property_handle(vertex_normals_,
-               "v:normals"))
-          refcount_vnormals_ = 1;
-      if(this->get_property_handle(vertex_colors_,
-               "v:colors"))
-          refcount_vcolors_ = 1;
-      if(this->get_property_handle(vertex_texcoords1D_,
-               "v:texcoords1D"))
-          refcount_vtexcoords1D_ = 1;
-      if(this->get_property_handle(vertex_texcoords2D_,
-               "v:texcoords2D"))
-          refcount_vtexcoords2D_ = 1;
-      if(this->get_property_handle(vertex_texcoords3D_,
-               "v:texcoords3D"))
-          refcount_vtexcoords3D_ = 1;
-      if(this->get_property_handle(halfedge_texcoords1D_,
-               "h:texcoords1D"))
-          refcount_htexcoords1D_ = 1;
-      if(this->get_property_handle(halfedge_texcoords2D_,
-               "h:texcoords2D"))
-          refcount_htexcoords2D_ = 1;
-      if(this->get_property_handle(halfedge_texcoords3D_,
-               "h:texcoords3D"))
-          refcount_htexcoords3D_ = 1;
-      if(this->get_property_handle(halfedge_normals_,
-               "h:normals"))
-          refcount_henormals_ = 1;
-      if(this->get_property_handle(halfedge_colors_,
-               "h:colors"))
-          refcount_hecolors_ = 1;
-      if(this->get_property_handle(edge_colors_,
-               "e:colors"))
-          refcount_ecolors_ = 1;
-      if(this->get_property_handle(face_normals_,
-               "f:normals"))
-          refcount_fnormals_ = 1;
-      if(this->get_property_handle(face_colors_,
-               "f:colors"))
-          refcount_fcolors_ = 1;
-      if(this->get_property_handle(face_texture_index_,
-               "f:textureindex"))
-          refcount_ftextureIndex_ = 1;
+      refcount_vnormals_ = this->get_property_handle(vertex_normals_,
+          "v:normals") ? 1 : 0 ;
+      refcount_vcolors_ = this->get_property_handle(vertex_colors_,
+          "v:colors") ? 1 : 0 ;
+      refcount_vtexcoords1D_ = this->get_property_handle(vertex_texcoords1D_,
+          "v:texcoords1D") ? 1 : 0 ;
+      refcount_vtexcoords2D_ = this->get_property_handle(vertex_texcoords2D_,
+          "v:texcoords2D") ? 1 : 0 ;
+      refcount_vtexcoords3D_ = this->get_property_handle(vertex_texcoords3D_,
+          "v:texcoords3D") ? 1 : 0 ;
+      refcount_htexcoords1D_ = this->get_property_handle(halfedge_texcoords1D_,
+          "h:texcoords1D") ? 1 : 0 ;
+      refcount_htexcoords2D_ = this->get_property_handle(halfedge_texcoords2D_,
+          "h:texcoords2D") ? 1 : 0 ;
+      refcount_htexcoords3D_ = this->get_property_handle(halfedge_texcoords3D_,
+          "h:texcoords3D") ? 1 : 0 ;
+      refcount_henormals_ = this->get_property_handle(halfedge_normals_,
+          "h:normals") ? 1 : 0 ;
+      refcount_hecolors_ = this->get_property_handle(halfedge_colors_,
+          "h:colors") ? 1 : 0 ;
+      refcount_ecolors_ = this->get_property_handle(edge_colors_,
+          "e:colors") ? 1 : 0 ;
+      refcount_fnormals_ = this->get_property_handle(face_normals_,
+          "f:normals") ? 1 : 0 ;
+      refcount_fcolors_ = this->get_property_handle(face_colors_,
+          "f:colors") ? 1 : 0 ;
+      refcount_ftextureIndex_ = this->get_property_handle(face_texture_index_,
+          "f:textureindex") ? 1 : 0 ;
   }
 };
 

src/OpenMesh/Core/Mesh/Handles.hh

@@ -165,8 +165,9 @@ namespace std {
 
 template <>
 struct hash<OpenMesh::BaseHandle >
-  : public std::unary_function<OpenMesh::BaseHandle, std::size_t>
 {
+  typedef OpenMesh::BaseHandle argument_type;
+  typedef std::size_t result_type;
 
   std::size_t operator()(const OpenMesh::BaseHandle& h) const
   {
@@ -176,8 +177,9 @@ struct hash<OpenMesh::BaseHandle >
 
 template <>
 struct hash<OpenMesh::VertexHandle >
-  : public std::unary_function<OpenMesh::VertexHandle, std::size_t>
 {
+  typedef OpenMesh::VertexHandle argument_type;
+  typedef std::size_t result_type;
 
   std::size_t operator()(const OpenMesh::VertexHandle& h) const
   {
@@ -187,9 +189,11 @@ struct hash<OpenMesh::VertexHandle >
 
 template <>
 struct hash<OpenMesh::HalfedgeHandle >
-  : public std::unary_function<OpenMesh::HalfedgeHandle, std::size_t>
 {
 
+  typedef OpenMesh::HalfedgeHandle argument_type;
+  typedef std::size_t result_type;
+  
   std::size_t operator()(const OpenMesh::HalfedgeHandle& h) const
   {
     return h.idx();
@@ -198,9 +202,11 @@ struct hash<OpenMesh::HalfedgeHandle >
 
 template <>
 struct hash<OpenMesh::EdgeHandle >
-  : public std::unary_function<OpenMesh::EdgeHandle, std::size_t>
 {
 
+  typedef OpenMesh::EdgeHandle argument_type;
+  typedef std::size_t result_type;
+  
   std::size_t operator()(const OpenMesh::EdgeHandle& h) const
   {
     return h.idx();
@@ -209,9 +215,11 @@ struct hash<OpenMesh::EdgeHandle >
 
 template <>
 struct hash<OpenMesh::FaceHandle >
-  : public std::unary_function<OpenMesh::FaceHandle, std::size_t>
 {
 
+  typedef OpenMesh::FaceHandle argument_type;
+  typedef std::size_t result_type;
+  
   std::size_t operator()(const OpenMesh::FaceHandle& h) const
   {
     return h.idx();

src/OpenMesh/Core/Mesh/IteratorsT.hh

@@ -109,9 +109,6 @@ class GenericIteratorT {
         : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
         {
             if (_skip) enable_skipping();
-
-            // Set vertex handle invalid if the mesh contains no vertex
-            if((mesh_->*PrimitiveCountMember)() == 0) hnd_ = value_handle(-1);
         }
 
         /// Standard dereferencing operator.

src/OpenMesh/Core/Mesh/PolyConnectivity.cc

@@ -777,6 +777,11 @@ void PolyConnectivity::collapse_edge(HalfedgeHandle _hh)
   // delete stuff
   status(edge_handle(h)).set_deleted(true);
   status(vo).set_deleted(true);
+  if (has_halfedge_status())
+  {
+    status(h).set_deleted(true);
+    status(o).set_deleted(true);
+  }
 }
 
 //-----------------------------------------------------------------------------
@@ -827,6 +832,11 @@ void PolyConnectivity::collapse_loop(HalfedgeHandle _hh)
     status(fh).set_deleted(true);
   }
   status(edge_handle(h0)).set_deleted(true);
+  if (has_halfedge_status())
+  {
+    status(h0).set_deleted(true);
+    status(o0).set_deleted(true);
+  }
 }
 
 //-----------------------------------------------------------------------------

src/OpenMesh/Core/Mesh/PolyConnectivity.hh

@@ -1138,45 +1138,89 @@ public:
           PolyConnectivity::ConstVertexIter,
           &PolyConnectivity::vertices_begin,
           &PolyConnectivity::vertices_end> ConstVertexRange;
+  typedef EntityRange<
+          const PolyConnectivity,
+          PolyConnectivity::ConstVertexIter,
+          &PolyConnectivity::vertices_sbegin,
+          &PolyConnectivity::vertices_end> ConstVertexRangeSkipping;
   typedef EntityRange<
           const PolyConnectivity,
           PolyConnectivity::ConstHalfedgeIter,
           &PolyConnectivity::halfedges_begin,
           &PolyConnectivity::halfedges_end> ConstHalfedgeRange;
+  typedef EntityRange<
+          const PolyConnectivity,
+          PolyConnectivity::ConstHalfedgeIter,
+          &PolyConnectivity::halfedges_sbegin,
+          &PolyConnectivity::halfedges_end> ConstHalfedgeRangeSkipping;
   typedef EntityRange<
           const PolyConnectivity,
           PolyConnectivity::ConstEdgeIter,
           &PolyConnectivity::edges_begin,
           &PolyConnectivity::edges_end> ConstEdgeRange;
+  typedef EntityRange<
+          const PolyConnectivity,
+          PolyConnectivity::ConstEdgeIter,
+          &PolyConnectivity::edges_sbegin,
+          &PolyConnectivity::edges_end> ConstEdgeRangeSkipping;
   typedef EntityRange<
           const PolyConnectivity,
           PolyConnectivity::ConstFaceIter,
           &PolyConnectivity::faces_begin,
           &PolyConnectivity::faces_end> ConstFaceRange;
+  typedef EntityRange<
+          const PolyConnectivity,
+          PolyConnectivity::ConstFaceIter,
+          &PolyConnectivity::faces_sbegin,
+          &PolyConnectivity::faces_end> ConstFaceRangeSkipping;
 
   /**
    * @return The vertices as a range object suitable
-   * for C++11 range based for loops.
+   * for C++11 range based for loops. Will skip deleted vertices.
    */
-  ConstVertexRange vertices() const { return ConstVertexRange(*this); }
+  ConstVertexRangeSkipping vertices() const { return ConstVertexRangeSkipping(*this); }
+
+  /**
+   * @return The vertices as a range object suitable
+   * for C++11 range based for loops. Will include deleted vertices.
+   */
+  ConstVertexRange all_vertices() const { return ConstVertexRange(*this); }
 
   /**
    * @return The halfedges as a range object suitable
-   * for C++11 range based for loops.
+   * for C++11 range based for loops. Will skip deleted halfedges.
    */
-  ConstHalfedgeRange halfedges() const { return ConstHalfedgeRange(*this); }
+  ConstHalfedgeRangeSkipping halfedges() const { return ConstHalfedgeRangeSkipping(*this); }
 
   /**
-   * @return The edges as a range object suitabl
-   * for C++11 range based for loops.
+   * @return The halfedges as a range object suitable
+   * for C++11 range based for loops. Will include deleted halfedges.
    */
-  ConstEdgeRange edges() const { return ConstEdgeRange(*this); }
+  ConstHalfedgeRange all_halfedges() const { return ConstHalfedgeRange(*this); }
+
+  /**
+   * @return The edges as a range object suitable
+   * for C++11 range based for loops. Will skip deleted edges.
+   */
+  ConstEdgeRangeSkipping edges() const { return ConstEdgeRangeSkipping(*this); }
+
+  /**
+   * @return The edges as a range object suitable
+   * for C++11 range based for loops. Will include deleted edges.
+   */
+  ConstEdgeRange all_edges() const { return ConstEdgeRange(*this); }
 
   /**
    * @return The faces as a range object suitable
-   * for C++11 range based for loops.
+   * for C++11 range based for loops. Will skip deleted faces.
    */
-  ConstFaceRange faces() const { return ConstFaceRange(*this); }
+  ConstFaceRangeSkipping faces() const { return ConstFaceRangeSkipping(*this); }
+
+  /**
+   * @return The faces as a range object suitable
+   * for C++11 range based for loops. Will include deleted faces.
+   */
+  ConstFaceRange all_faces() const { return ConstFaceRange(*this); }
 
   /// Generic class for iterator ranges.
   template<

src/OpenMesh/Core/Mesh/PolyMeshT.cc

@@ -139,18 +139,18 @@ PolyMeshT<Kernel>::calc_face_normal_impl(FaceHandle _fh, PointIs3DTag) const
 
     // Due to traits, the value types of normals and points can be different.
     // Therefore we cast them here.
-    n[0] += static_cast<typename Normal::value_type>(a[1] * b[2]);
-    n[1] += static_cast<typename Normal::value_type>(a[2] * b[0]);
-    n[2] += static_cast<typename Normal::value_type>(a[0] * b[1]);
+    n[0] += static_cast<typename vector_traits<Normal>::value_type>(a[1] * b[2]);
+    n[1] += static_cast<typename vector_traits<Normal>::value_type>(a[2] * b[0]);
+    n[2] += static_cast<typename vector_traits<Normal>::value_type>(a[0] * b[1]);
   }
 
-  const typename vector_traits<Normal>::value_type norm = n.length();
+  const typename vector_traits<Normal>::value_type length = norm(n);
   
   // The expression ((n *= (1.0/norm)),n) is used because the OpenSG
   // vector class does not return self after component-wise
   // self-multiplication with a scalar!!!
-  return (norm != typename vector_traits<Normal>::value_type(0))
-          ? ((n *= (typename vector_traits<Normal>::value_type(1)/norm)), n)
+  return (length != typename vector_traits<Normal>::value_type(0))
+          ? ((n *= (typename vector_traits<Normal>::value_type(1)/length)), n)
           : Normal(0, 0, 0);
 }
 
@@ -194,20 +194,22 @@ calc_face_normal_impl(const Point& _p0,
   Normal p1p2(vector_cast<Normal>(_p2));  p1p2 -= vector_cast<Normal>(_p1);
 
   Normal n    = cross(p1p2, p1p0);
-  typename vector_traits<Normal>::value_type norm = n.length();
+  typename vector_traits<Normal>::value_type length = norm(n);
 
   // The expression ((n *= (1.0/norm)),n) is used because the OpenSG
   // vector class does not return self after component-wise
   // self-multiplication with a scalar!!!
-  return (norm != typename vector_traits<Normal>::value_type(0)) ? ((n *= (typename vector_traits<Normal>::value_type(1)/norm)),n) : Normal(0,0,0);
+  return (length != typename vector_traits<Normal>::value_type(0))
+          ? ((n *= (typename vector_traits<Normal>::value_type(1)/length)),n)
+          : Normal(0,0,0);
 #else
   Point p1p0 = _p0;  p1p0 -= _p1;
   Point p1p2 = _p2;  p1p2 -= _p1;
 
   Normal n = vector_cast<Normal>(cross(p1p2, p1p0));
-  typename vector_traits<Normal>::value_type norm = n.length();
+  typename vector_traits<Normal>::value_type length = norm(n);
 
-  return (norm != 0.0) ? n *= (1.0/norm) : Normal(0,0,0);
+  return (length != 0.0) ? n *= (1.0/length) : Normal(0,0,0);
 #endif
 }
 
@@ -226,7 +228,7 @@ PolyMeshT<Kernel>::
 calc_face_centroid(FaceHandle _fh) const
 {
   Point _pt;
-  _pt.vectorize(0);
+  vectorize(_pt, 0);
   Scalar valence = 0.0;
   for (ConstFaceVertexIter cfv_it = this->cfv_iter(_fh); cfv_it.is_valid(); ++cfv_it, valence += 1.0)
   {
@@ -261,7 +263,7 @@ void
 PolyMeshT<Kernel>::
 update_face_normals()
 {
-  FaceIter f_it(Kernel::faces_begin()), f_end(Kernel::faces_end());
+  FaceIter f_it(Kernel::faces_sbegin()), f_end(Kernel::faces_end());
 
   for (; f_it != f_end; ++f_it)
     this->set_normal(*f_it, calc_face_normal(*f_it));
@@ -331,7 +333,7 @@ calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle) const
     for(unsigned int i=0; i<fhs.size(); ++i)
       n += Kernel::normal(fhs[i]);
 
-    return n.normalize();
+    return normalize(n);
   }
 }
 
@@ -378,8 +380,8 @@ calc_vertex_normal(VertexHandle _vh) const
   Normal n;
   calc_vertex_normal_fast(_vh,n);
 
-  Scalar norm = n.length();
-  if (norm != 0.0) n *= (Scalar(1.0)/norm);
+  Scalar length = norm(n);
+  if (length != 0.0) n *= (Scalar(1.0)/length);
 
   return n;
 }
@@ -389,7 +391,7 @@ template <class Kernel>
 void PolyMeshT<Kernel>::
 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
 {
-  _n.vectorize(0.0);
+  vectorize(_n, 0.0);
   for (ConstVertexFaceIter vf_it = this->cvf_iter(_vh); vf_it.is_valid(); ++vf_it)
     _n += this->normal(*vf_it);
 }
@@ -399,7 +401,7 @@ template <class Kernel>
 void PolyMeshT<Kernel>::
 calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const
 {
-  _n.vectorize(0.0);
+  vectorize(_n, 0.0);
   ConstVertexIHalfedgeIter cvih_it = this->cvih_iter(_vh);
   if (! cvih_it.is_valid() )
   {//don't crash on isolated vertices

src/OpenMesh/Core/Mesh/PolyMeshT.hh

@@ -408,7 +408,7 @@ public:
   {
     Normal edge_vec;
     calc_edge_vector(_heh, edge_vec);
-    return edge_vec.sqrnorm();
+    return sqrnorm(edge_vec);
   }
 
   /** Calculates the midpoint of the halfedge _heh, defined by the positions of
@@ -446,8 +446,8 @@ public:
   {
     Normal v0, v1;
     calc_sector_vectors(_in_heh, v0, v1);
-    Scalar denom = v0.norm()*v1.norm();
-    if (is_zero(denom))
+    Scalar denom = norm(v0)*norm(v1);
+    if ( denom == Scalar(0))
     {
       return 0;
     }
@@ -472,7 +472,7 @@ public:
     Normal in_vec, out_vec;
     calc_edge_vector(_in_heh, in_vec);
     calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
-    Scalar denom = in_vec.norm()*out_vec.norm();
+    Scalar denom = norm(in_vec)*norm(out_vec);
     if (is_zero(denom))
     {
       _cos_a = 1;
@@ -481,7 +481,7 @@ public:
     else
     {
       _cos_a = dot(in_vec, out_vec)/denom;
-      _sin_a = cross(in_vec, out_vec).norm()/denom;
+      _sin_a = norm(cross(in_vec, out_vec))/denom;
     }
   }
   */
@@ -501,7 +501,7 @@ public:
   {
     Normal sector_normal;
     calc_sector_normal(_in_heh, sector_normal);
-    return sector_normal.norm()/2;
+    return norm(sector_normal)/2;
   }
 
   /** calculates the dihedral angle on the halfedge _heh
@@ -541,7 +541,7 @@ public:
     calc_sector_normal(_heh, n0);
     calc_sector_normal(this->opposite_halfedge_handle(_heh), n1);
     calc_edge_vector(_heh, he);
-    Scalar denom = n0.norm()*n1.norm();
+    Scalar denom = norm(n0)*norm(n1);
     if (denom == Scalar(0))
     {
       return 0;

src/OpenMesh/Core/Mesh/TriConnectivity.cc

@@ -488,6 +488,11 @@ void TriConnectivity::split(EdgeHandle _eh, VertexHandle _vh)
 
 void TriConnectivity::split_copy(EdgeHandle _eh, VertexHandle _vh)
 {
+  const VertexHandle v0 = to_vertex_handle(halfedge_handle(_eh, 0));
+  const VertexHandle v1 = to_vertex_handle(halfedge_handle(_eh, 1));
+
+  const int nf = n_faces();
+
   // Split the halfedge ( handle will be preserved)
   split(_eh, _vh);
 
@@ -495,6 +500,22 @@ void TriConnectivity::split_copy(EdgeHandle _eh, VertexHandle _vh)
   // have been created
   for(VEIter ve_it = ve_iter(_vh); ve_it.is_valid(); ++ve_it)
     copy_all_properties(_eh, *ve_it, true);
+
+  for (auto vh : {v0, v1})
+  {
+    // get the halfedge pointing from new vertex to old vertex
+    const HalfedgeHandle h = find_halfedge(_vh, vh);
+    if (!is_boundary(h)) // for boundaries there are no faces whose properties need to be copied
+    {
+      FaceHandle fh0 = face_handle(h);
+      FaceHandle fh1 = face_handle(opposite_halfedge_handle(prev_halfedge_handle(h)));
+      if (fh0.idx() >= nf) // is fh0 the new face?
+        std::swap(fh0, fh1);
+
+      // copy properties from old face to new face
+      copy_all_properties(fh0, fh1, true);
+    }
+  }
 }
 
 }// namespace OpenMesh

src/OpenMesh/Core/Mesh/TriMeshT.hh

@@ -361,9 +361,9 @@ public:
     VertexHandle p2 = this->to_vertex_handle(he2);
 
     // Calculate midpoint coordinates
-    const Point new0 = (this->point(p0) + this->point(p2)) * static_cast< typename Point::value_type >(0.5);
-    const Point new1 = (this->point(p0) + this->point(p1)) * static_cast< typename Point::value_type >(0.5);
-    const Point new2 = (this->point(p1) + this->point(p2)) * static_cast< typename Point::value_type >(0.5);
+    const Point new0 = (this->point(p0) + this->point(p2)) * static_cast<typename vector_traits<Point>::value_type >(0.5);
+    const Point new1 = (this->point(p0) + this->point(p1)) * static_cast<typename vector_traits<Point>::value_type >(0.5);
+    const Point new2 = (this->point(p1) + this->point(p2)) * static_cast<typename vector_traits<Point>::value_type >(0.5);
 
     // Add vertices at midpoint coordinates
     VertexHandle v0 = this->add_vertex(new0);

src/OpenMesh/Core/System/config.h

@@ -65,15 +65,11 @@
 // ----------------------------------------------------------------------------
 
 
-#define OM_VERSION 0x70000
-//#define OM_VERSION 0x60300
+#define OM_VERSION 0x70200
 
-// only defined, if it is a beta version
-//#define OM_VERSION_BETA 4
-
-#define OM_GET_VER ((OM_VERSION && 0xf0000) >> 16)
-#define OM_GET_MAJ ((OM_VERSION && 0x0ff00) >> 8)
-#define OM_GET_MIN  (OM_VERSION && 0x000ff)
+#define OM_GET_VER ((OM_VERSION & 0xf0000) >> 16)
+#define OM_GET_MAJ ((OM_VERSION & 0x0ff00) >> 8)
+#define OM_GET_MIN  (OM_VERSION & 0x000ff)
 
 #ifdef WIN32
 #  ifdef min

src/OpenMesh/Core/Utils/vector_cast.hh

@@ -95,7 +95,6 @@ inline void vector_cast( const src_t & /*_src*/, dst_t & /*_dst*/, GenProg::Int2
 {
 }
 
-
 template <typename src_t, typename dst_t, int n>
 inline void vector_copy( const src_t &_src, dst_t &_dst, GenProg::Int2Type<n> )
 {

src/OpenMesh/Examples/Examples.pro

@@ -1,12 +0,0 @@
-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

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial02.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial03.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial04.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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_algo.hh

@@ -13,7 +13,7 @@ public:
 public:
 
   // construct with a given mesh
-  SmootherT(Mesh& _mesh) 
+  explicit SmootherT(Mesh& _mesh) 
     : mesh_(_mesh)
   { 
     mesh_.add_property( cog_ );

src/OpenMesh/Examples/Tutorial05/Tutorial05.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial06.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial07/Tutorial07.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial08/Tutorial08.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial09/Tutorial09.pro

@@ -1,19 +0,0 @@
-################################################################################
-#
-################################################################################
-
-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/Tutorial10/Tutorial10.pro

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

src/OpenMesh/Tools/Smoother/JacobiLaplaceSmootherT.cc

@@ -181,7 +181,7 @@ compute_new_positions_C1()
       if (diag) uu *= static_cast<typename Mesh::Scalar>(1.0) / diag;
 
       // damping
-      uu *= static_cast<typename Mesh::Normal::value_type>(0.25);
+      uu *= static_cast<typename vector_traits<typename Mesh::Normal>::value_type>(0.25);
     
       // store new position
       p  = vector_cast<typename Mesh::Normal>(Base::mesh_.point(*v_it));

src/OpenMesh/Tools/Smoother/SmootherT.cc

@@ -263,13 +263,13 @@ set_relative_local_error(Scalar _err)
     bb_min = bb_max = mesh_.point(*v_it);
     for (++v_it; v_it!=v_end; ++v_it)
     {
-      bb_min.minimize(mesh_.point(*v_it));
-      bb_max.maximize(mesh_.point(*v_it));
+        minimize(bb_min, mesh_.point(*v_it));
+        maximize(bb_max, mesh_.point(*v_it));
     }
 
 
     // abs. error = rel. error * bounding-diagonal
-    set_absolute_local_error(_err * (bb_max-bb_min).norm());
+    set_absolute_local_error(norm(_err * (bb_max-bb_min)));
   }
 }
 

src/OpenMesh/Tools/Subdivider/Adaptive/Composite/RulesT.hh

@@ -104,7 +104,7 @@ public:
 
   typedef RuleInterfaceT<M> Inherited;
 
-  Tvv3(M& _mesh) : Inherited(_mesh) { Base::set_subdiv_type(3); };
+  explicit Tvv3(M& _mesh) : Inherited(_mesh) { Base::set_subdiv_type(3); };
 
   void raise(typename M::FaceHandle&   _fh, state_t _target_state);
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
@@ -129,7 +129,7 @@ public:
    
   typedef RuleInterfaceT<M> Inherited;
 
-  Tvv4(M& _mesh) : Inherited(_mesh) { Base::set_subdiv_type(4); };
+  explicit Tvv4(M& _mesh) : Inherited(_mesh) { Base::set_subdiv_type(4); };
 
   void raise(typename M::FaceHandle&   _fh, state_t _target_state); 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
@@ -157,7 +157,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  VF(M& _mesh) : Inherited(_mesh) {}
+  explicit VF(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::FaceHandle& _fh, state_t _target_state);
   MIPS_WARN_WA(Edge)
@@ -179,7 +179,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  FF(M& _mesh) : Inherited(_mesh) {}
+  explicit FF(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::FaceHandle& _fh, state_t _target_state);
   MIPS_WARN_WA(Vertex) // avoid warning
@@ -201,7 +201,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  FFc(M& _mesh) : Inherited(_mesh) {}
+  explicit FFc(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::FaceHandle& _fh, state_t _target_state);
   MIPS_WARN_WA(Vertex) // avoid warning
@@ -223,7 +223,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  FV(M& _mesh) : Inherited(_mesh) {}
+  explicit FV(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
   MIPS_WARN_WA(Face) // avoid warning
@@ -245,7 +245,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  FVc(M& _mesh) : Inherited(_mesh) { init_coeffs(50); }
+  explicit FVc(M& _mesh) : Inherited(_mesh) { init_coeffs(50); }
 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
   MIPS_WARN_WA(Face) // avoid warning
@@ -282,7 +282,7 @@ public:
 
   typedef RuleInterfaceT<M> Inherited;
 
-  VV(M& _mesh) : Inherited(_mesh) {}
+  explicit VV(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
   MIPS_WARN_WA(Face) // avoid warning
@@ -304,7 +304,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  VVc(M& _mesh) : Inherited(_mesh) {}
+  explicit VVc(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
   MIPS_WARN_WA(Face) // avoid warning
@@ -326,7 +326,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  VE(M& _mesh) : Inherited(_mesh) {}
+  explicit VE(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::EdgeHandle& _eh, state_t _target_state);
   MIPS_WARN_WA(Face  ) // avoid warning
@@ -348,7 +348,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  VdE(M& _mesh) : Inherited(_mesh) {}
+  explicit VdE(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::EdgeHandle& _eh, state_t _target_state);
   MIPS_WARN_WA(Face  ) // avoid warning
@@ -370,7 +370,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  VdEc(M& _mesh) : Inherited(_mesh) {}
+  explicit VdEc(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::EdgeHandle& _eh, state_t _target_state);
   MIPS_WARN_WA(Face  ) // avoid warning
@@ -392,7 +392,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  EV(M& _mesh) : Inherited(_mesh) {}
+  explicit EV(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
   MIPS_WARN_WA(Face) // avoid warning
@@ -415,7 +415,7 @@ public:
 
   typedef RuleInterfaceT<M> Inherited;
 
-  EVc(M& _mesh) : Inherited(_mesh) { init_coeffs(50); }
+  explicit EVc(M& _mesh) : Inherited(_mesh) { init_coeffs(50); }
 
   void raise(typename M::VertexHandle& _vh, state_t _target_state);
   MIPS_WARN_WA(Face) // avoid warning
@@ -451,7 +451,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  EF(M& _mesh) : Inherited(_mesh) {}
+  explicit EF(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::FaceHandle& _fh, state_t _target_state);
   MIPS_WARN_WA(Edge  ) // avoid warning
@@ -473,7 +473,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  FE(M& _mesh) : Inherited(_mesh) {}
+  explicit FE(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::EdgeHandle& _eh, state_t _target_state);
   MIPS_WARN_WA(Face  ) // avoid warning
@@ -495,7 +495,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  EdE(M& _mesh) : Inherited(_mesh) {}
+  explicit EdE(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::EdgeHandle& _eh, state_t _target_state);
   MIPS_WARN_WA(Face  ) // avoid warning
@@ -517,7 +517,7 @@ private:
 public:
   typedef RuleInterfaceT<M> Inherited;
 
-  EdEc(M& _mesh) : Inherited(_mesh) {}
+  explicit EdEc(M& _mesh) : Inherited(_mesh) {}
 
   void raise(typename M::EdgeHandle& _eh, state_t _target_state);
   MIPS_WARN_WA(Face  ) // avoid warning

src/OpenMesh/Tools/Subdivider/Uniform/CatmullClarkT.cc

@@ -346,7 +346,7 @@ CatmullClarkT<MeshType,RealType>::update_vertex( MeshType& _m, const VertexHandl
     for ( ve_itr = _m.ve_iter( _vh); ve_itr.is_valid(); ++ve_itr)
       if ( _m.is_boundary( *ve_itr))
         pos += _m.property( ep_pos_, *ve_itr);
-    pos /= static_cast<typename MeshType::Point::value_type>(3.0);
+    pos /= static_cast<typename vector_traits<typename MeshType::Point>::value_type>(3.0);
   }
   else // inner vertex
   {

src/OpenMesh/Tools/Tools.pro

@@ -1,45 +0,0 @@
-################################################################################
-#
-################################################################################
-
-include( $$TOPDIR/qmake/all.include )
-
-Library()
-
-contains( OPENFLIPPER , OpenFlipper ){
-        DESTDIR = $${TOPDIR}/OpenMesh/lib
-} else {
-        DESTDIR = $${TOPDIR}/lib
-}
-
-DIRECTORIES = . Decimater Smoother Subdivider/Adaptive/Composite \
-        	Subdivider/Uniform/Composite Subdivider/Uniform \
-		Utils
-
-INCLUDEPATH += ../..
-
-CONFIG( debug, debug|release ){
-        TARGET    = OpenMeshToolsd
-} else {
-        TARGET    = OpenMeshTools
-}
-
-win32 {
- DEFINES += _USE_MATH_DEFINES NOMINMAX
- CONFIG  += static
-}
-
-macx {
-      # Set library binary header to the correct path
-      QMAKE_LFLAGS_SONAME = -install_name$${LITERAL_WHITESPACE}$${DESTDIR}/
-      export(QMAKE_LFLAGS_SONAME)
-}
-
-# Input
-HEADERS += $$getFilesFromDir($$DIRECTORIES,*.hh)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.c)
-SOURCES += $$getFilesFromDir($$DIRECTORIES,*.cc) 
-FORMS   += $$getFilesFromDir($$DIRECTORIES,*.ui)
-
-
-################################################################################

src/OpenMesh/Tools/Utils/conio.cc

@@ -64,7 +64,7 @@ int getche() { return ::_getche(); }
 } // AS
 
 // ----------------------------------------------------------------- Win32 ----
-#elif defined(WIN32)
+#elif defined(WIN32) || defined(__MINGW32__)
 
 #include <conio.h>
 
@@ -91,6 +91,7 @@ int getche() { return ::getche(); }
 #endif
 #include <termios.h>   /* tcsetattr()    */
 #include <sys/ioctl.h> /* ioctl()        */
+#include <sys/time.h>  /* timeval struct */ 
 
 namespace OpenMesh {
 namespace Utils {

src/Python/Bindings.cc

@@ -1,152 +0,0 @@
-#include "Python/Bindings.hh"
-#include "Python/Vector.hh"
-#include "Python/Mesh.hh"
-#include "Python/PropertyManager.hh"
-#include "Python/InputOutput.hh"
-#include "Python/Decimater.hh"
-
-#include <memory>
-
-namespace OpenMesh {
-namespace Python {
-
-/**
- * Expose mesh items to %Python.
- */
-void expose_items() {
-	class_<ArrayItems::Vertex>("Vertex");
-	class_<ArrayItems::Halfedge>("Halfedge");
-	class_<ArrayItems::Edge>("Edge");
-	class_<ArrayItems::Face>("Face");
-}
-
-/**
- * Expose item and property handles to %Python.
- */
-void expose_handles() {
-	class_<BaseHandle>("BaseHandle", init<optional<int> >())
-		.def("idx", &BaseHandle::idx)
-		.def("is_valid", &BaseHandle::is_valid)
-		.def("reset", &BaseHandle::reset)
-		.def("invalidate", &BaseHandle::invalidate)
-		.def(self == self)
-		.def(self != self)
-		.def(self < self)
-		;
-
-	class_<VertexHandle, bases<BaseHandle> >("VertexHandle", init<optional<int> >());
-	class_<HalfedgeHandle, bases<BaseHandle> >("HalfedgeHandle", init<optional<int> >());
-	class_<EdgeHandle, bases<BaseHandle> >("EdgeHandle", init<optional<int> >());
-	class_<FaceHandle, bases<BaseHandle> >("FaceHandle", init<optional<int> >());
-
-	class_<BasePropHandleT<object>, bases<BaseHandle> >("BasePropHandle", init<optional<int> >());
-
-	class_<VPropHandleT<object>, bases<BasePropHandleT<object> > >("VPropHandle", init<optional<int> >())
-		.def(init<const BasePropHandleT<object>&>());
-	class_<HPropHandleT<object>, bases<BasePropHandleT<object> > >("HPropHandle", init<optional<int> >())
-		.def(init<const BasePropHandleT<object>&>());
-	class_<EPropHandleT<object>, bases<BasePropHandleT<object> > >("EPropHandle", init<optional<int> >())
-		.def(init<const BasePropHandleT<object>&>());
-	class_<FPropHandleT<object>, bases<BasePropHandleT<object> > >("FPropHandle", init<optional<int> >())
-		.def(init<const BasePropHandleT<object>&>());
-	class_<MPropHandleT<object>, bases<BasePropHandleT<object> > >("MPropHandle", init<optional<int> >())
-		.def(init<const BasePropHandleT<object>&>());
-}
-
-
-/**
- * Expose the StatusBits enum and StatusInfo class to %Python.
- */
-void expose_status_bits_and_info() {
-	using OpenMesh::Attributes::StatusBits;
-	using OpenMesh::Attributes::StatusInfo;
-
-	enum_<StatusBits>("StatusBits")
-		.value("DELETED", OpenMesh::Attributes::DELETED)
-		.value("LOCKED", OpenMesh::Attributes::LOCKED)
-		.value("SELECTED", OpenMesh::Attributes::SELECTED)
-		.value("HIDDEN", OpenMesh::Attributes::HIDDEN)
-		.value("FEATURE", OpenMesh::Attributes::FEATURE)
-		.value("TAGGED", OpenMesh::Attributes::TAGGED)
-		.value("TAGGED2", OpenMesh::Attributes::TAGGED2)
-		.value("FIXEDNONMANIFOLD", OpenMesh::Attributes::FIXEDNONMANIFOLD)
-		.value("UNUSED", OpenMesh::Attributes::UNUSED)
-		;
-
-	class_<StatusInfo>("StatusInfo")
-		.def("deleted", &StatusInfo::deleted)
-		.def("set_deleted", &StatusInfo::set_deleted)
-		.def("locked", &StatusInfo::locked)
-		.def("set_locked", &StatusInfo::set_locked)
-		.def("selected", &StatusInfo::selected)
-		.def("set_selected", &StatusInfo::set_selected)
-		.def("hidden", &StatusInfo::hidden)
-		.def("set_hidden", &StatusInfo::set_hidden)
-		.def("feature", &StatusInfo::feature)
-		.def("set_feature", &StatusInfo::set_feature)
-		.def("tagged", &StatusInfo::tagged)
-		.def("set_tagged", &StatusInfo::set_tagged)
-		.def("tagged2", &StatusInfo::tagged2)
-		.def("set_tagged2", &StatusInfo::set_tagged2)
-		.def("fixed_nonmanifold", &StatusInfo::fixed_nonmanifold)
-		.def("set_fixed_nonmanifold", &StatusInfo::set_fixed_nonmanifold)
-		.def("bits", &StatusInfo::bits)
-		.def("set_bits", &StatusInfo::set_bits)
-		.def("is_bit_set", &StatusInfo::is_bit_set)
-		.def("set_bit", &StatusInfo::set_bit)
-		.def("unset_bit", &StatusInfo::unset_bit)
-		.def("change_bit", &StatusInfo::change_bit)
-		;
-}
-
-BOOST_PYTHON_MODULE(openmesh) {
-	expose_items();
-	expose_handles();
-	expose_status_bits_and_info();
-
-	expose_vec<float,  2>("Vec2f");
-	expose_vec<float,  3>("Vec3f");
-	expose_vec<float,  4>("Vec4f");
-	expose_vec<double, 2>("Vec2d");
-	expose_vec<double, 3>("Vec3d");
-	expose_vec<double, 4>("Vec4d");
-
-	expose_mesh<PolyMesh>("PolyMesh");
-	expose_mesh<TriMesh>("TriMesh");
-
-	expose_iterator<OpenMesh::PolyConnectivity::VertexIter, &OpenMesh::ArrayKernel::n_vertices>("VertexIter");
-	expose_iterator<OpenMesh::PolyConnectivity::HalfedgeIter, &OpenMesh::ArrayKernel::n_halfedges>("HalfedgeIter");
-	expose_iterator<OpenMesh::PolyConnectivity::EdgeIter, &OpenMesh::ArrayKernel::n_edges>("EdgeIter");
-	expose_iterator<OpenMesh::PolyConnectivity::FaceIter, &OpenMesh::ArrayKernel::n_faces>("FaceIter");
-
-	expose_circulator<OpenMesh::PolyConnectivity::VertexVertexIter, VertexHandle>("VertexVertexIter");
-	expose_circulator<OpenMesh::PolyConnectivity::VertexIHalfedgeIter, VertexHandle>("VertexIHalfedgeIter");
-	expose_circulator<OpenMesh::PolyConnectivity::VertexOHalfedgeIter, VertexHandle>("VertexOHalfedgeIter");
-	expose_circulator<OpenMesh::PolyConnectivity::VertexEdgeIter, VertexHandle>("VertexEdgeIter");
-	expose_circulator<OpenMesh::PolyConnectivity::VertexFaceIter, VertexHandle>("VertexFaceIter");
-
-	expose_circulator<OpenMesh::PolyConnectivity::FaceVertexIter, FaceHandle>("FaceVertexIter");
-	expose_circulator<OpenMesh::PolyConnectivity::FaceHalfedgeIter, FaceHandle>("FaceHalfedgeIter");
-	expose_circulator<OpenMesh::PolyConnectivity::FaceEdgeIter, FaceHandle>("FaceEdgeIter");
-	expose_circulator<OpenMesh::PolyConnectivity::FaceFaceIter, FaceHandle>("FaceFaceIter");
-
-	expose_circulator<OpenMesh::PolyConnectivity::HalfedgeLoopIter, HalfedgeHandle>("HalfedgeLoopIter");
-
-	typedef IteratorWrapperT<PolyConnectivity::VertexIter, &ArrayKernel::n_vertices> VertexIterWrapper;
-	typedef IteratorWrapperT<PolyConnectivity::HalfedgeIter, &ArrayKernel::n_halfedges> HalfedgeIterWrapper;
-	typedef IteratorWrapperT<PolyConnectivity::EdgeIter, &ArrayKernel::n_edges> EdgeIterWrapper;
-	typedef IteratorWrapperT<PolyConnectivity::FaceIter, &ArrayKernel::n_faces> FaceIterWrapper;
-
-	expose_property_manager<VPropHandleT<object>, VertexHandle, VertexIterWrapper>("VPropertyManager");
-	expose_property_manager<HPropHandleT<object>, HalfedgeHandle, HalfedgeIterWrapper>("HPropertyManager");
-	expose_property_manager<EPropHandleT<object>, EdgeHandle, EdgeIterWrapper>("EPropertyManager");
-	expose_property_manager<FPropHandleT<object>, FaceHandle, FaceIterWrapper>("FPropertyManager");
-
-	expose_io();
-
-	expose_decimater<PolyMesh>("PolyMesh");
-	expose_decimater<TriMesh>("TriMesh");
-}
-
-} // namespace Python
-} // namespace OpenMesh

src/Python/Bindings.hh

@@ -1,48 +0,0 @@
-/** @file */
-
-#ifndef OPENMESH_PYTHON_BINDINGS_HH
-#define OPENMESH_PYTHON_BINDINGS_HH
-
-#include <boost/python.hpp>
-#include <boost/python/return_internal_reference.hpp>
-#include <boost/python/reference_existing_object.hpp>
-#include <boost/python/copy_const_reference.hpp>
-
-#include "OpenMesh/Core/IO/MeshIO.hh"
-#include "OpenMesh/Core/Mesh/TriMesh_ArrayKernelT.hh"
-#include "OpenMesh/Core/Mesh/PolyMesh_ArrayKernelT.hh"
-
-using namespace boost::python;
-
-namespace OpenMesh {
-
-/**
- * This namespace contains classes and functions that are used to expose
- * %OpenMesh to %Python.
- */
-namespace Python {
-
-/**
- * Return value policy for functions that return references to objects that are
- * managed by %OpenMesh.
- */
-#define OPENMESH_PYTHON_DEFAULT_POLICY return_value_policy<copy_const_reference>()
-
-struct MeshTraits : public OpenMesh::DefaultTraits {
-	/** Use double precision points */
-	typedef OpenMesh::Vec3d Point;
-
-	/** Use double precision normals */
-	typedef OpenMesh::Vec3d Normal;
-
-	/** Use RGBA colors */
-	typedef OpenMesh::Vec4f Color;
-};
-
-typedef OpenMesh::TriMesh_ArrayKernelT<MeshTraits> TriMesh;
-typedef OpenMesh::PolyMesh_ArrayKernelT<MeshTraits> PolyMesh;
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/CMakeLists.txt

@@ -1,215 +0,0 @@
-IF(NOT DEFINED OPENMESH_BUILD_PYTHON_BINDINGS)
-	SET(OPENMESH_BUILD_PYTHON_BINDINGS TRUE CACHE BOOL "Enable or disable building the Python Bindings.")
-ENDIF()
-
-IF(NOT DEFINED OPENMESH_BUILD_PYTHON_UNIT_TESTS)
-	SET(OPENMESH_BUILD_PYTHON_UNIT_TESTS FALSE CACHE BOOL "Enable or disable building the Python unit tests.")
-ENDIF()
-
-IF(NOT DEFINED OPENMESH_PYTHON_VERSION)
-	SET(OPENMESH_PYTHON_VERSION "2.7" CACHE STRING "Choose the Python version that is used to build the Python Bindings.")
-ENDIF()
-
-IF(OPENMESH_BUILD_PYTHON_BINDINGS)
-	# Create log file
-	SET(PYTHONLOG "${CMAKE_CURRENT_BINARY_DIR}/PythonLog.txt")
-	FILE(WRITE ${PYTHONLOG} "")
-
-	# Look for the python libs
-	MESSAGE(STATUS "Looking for PythonLibs")
-	FIND_PACKAGE(PythonLibs ${OPENMESH_PYTHON_VERSION} QUIET)
-
-	IF(PYTHONLIBS_FOUND)
-		MESSAGE(STATUS "Looking for PythonLibs -- found")
-
-		# Determine the name of the python component
-		STRING(REGEX MATCH "^[0-9]+\\.[0-9]+" PYTHON_VERSION_MAJOR_MINOR ${PYTHONLIBS_VERSION_STRING})
-		STRING(REGEX REPLACE "\\." "" PYTHON_VERSION_MAJOR_MINOR ${PYTHON_VERSION_MAJOR_MINOR})
-		STRING(REGEX MATCH "^[0-9]" PYTHON_VERSION_MAJOR ${PYTHON_VERSION_MAJOR_MINOR})
-
-		MESSAGE(STATUS "Looking for Boost Python")
-
-		SET(BOOST_PYTHON_COMPONENT_NAMES "python-py${PYTHON_VERSION_MAJOR_MINOR}" "python${PYTHON_VERSION_MAJOR}" "python")
-
-		FOREACH(NAME ${BOOST_PYTHON_COMPONENT_NAMES})
-			IF(NOT Boost_FOUND)
-				FILE(APPEND ${PYTHONLOG} "Looking for component ${NAME}\n")
-				FIND_PACKAGE(Boost QUIET COMPONENTS ${NAME})
-			ENDIF()
-		ENDFOREACH()
-
-		FILE(APPEND ${PYTHONLOG} "\n")
-
-		IF(Boost_FOUND)
-			MESSAGE(STATUS "Looking for Boost Python -- found")
-			MESSAGE(STATUS "Checking the Boost Python configuration")
-
-			SET(CMAKE_TRY_COMPILE_CONFIGURATION "Release")
-			
-			TRY_COMPILE(
-				COMPILE_WORKS
-				${CMAKE_CURRENT_BINARY_DIR}
-				${CMAKE_CURRENT_SOURCE_DIR}/Example/
-				Example
-				CMAKE_FLAGS
-					"-DINCLUDE_DIRECTORIES:STRING=${PYTHON_INCLUDE_DIRS};${Boost_INCLUDE_DIRS}"
-					"-DLINK_DIRECTORIES:STRING=${Boost_LIBRARY_DIRS}"
-					"-DLINK_LIBRARIES:STRING=${PYTHON_LIBRARIES};${Boost_LIBRARIES}"
-				OUTPUT_VARIABLE OUTPUT_TRY_COMPILE
-			)
-
-			FILE(APPEND ${PYTHONLOG} "INCLUDE_DIRECTORIES: ${PYTHON_INCLUDE_DIRS};${Boost_INCLUDE_DIRS}\n")
-			FILE(APPEND ${PYTHONLOG} "LINK_DIRECTORIES: ${Boost_LIBRARY_DIRS}\n")
-			FILE(APPEND ${PYTHONLOG} "LINK_LIBRARIES: ${PYTHON_LIBRARIES};${Boost_LIBRARIES}\n\n")
-			FILE(APPEND ${PYTHONLOG} "${OUTPUT_TRY_COMPILE}")
-
-			IF(COMPILE_WORKS)
-				# Look for the python interpreter to check if the example works
-
-				# strip version string of any characters (e.g. rc1 # '+') than 0-9 and .
-				STRING(REGEX REPLACE "(rc[0-9]+)|[^ 0-9 | \\.]" "" PYTHONLIBS_VERSION_STRING_STRIPPED ${PYTHONLIBS_VERSION_STRING})
-				FIND_PACKAGE(PythonInterp ${PYTHONLIBS_VERSION_STRING_STRIPPED} QUIET)
-
-				IF(PYTHONINTERP_FOUND)
-					
-					IF(MSVC)
-						SET(PYTHON_WORKING_DIR "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_TRY_COMPILE_CONFIGURATION}")
-					ELSE()
-						SET(PYTHON_WORKING_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-					ENDIF()
-					
-					EXECUTE_PROCESS(
-						COMMAND ${PYTHON_EXECUTABLE} -c "from example import *; greet(); planet = World()"
-						WORKING_DIRECTORY ${PYTHON_WORKING_DIR}
-						RESULT_VARIABLE PYTHON_WORKS
-						OUTPUT_QUIET
-						ERROR_QUIET
-					)
-
-					IF(PYTHON_WORKS EQUAL 0)
-
-						### EVERYTHING WORKS ###
-
-						MESSAGE(STATUS "Checking the Boost Python configuration -- done")
-
-						IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" AND ${Boost_VERSION} VERSION_LESS 105600)
-							MESSAGE("There are known issues with Clang and Boost Python 1.55 and below.")
-							MESSAGE("Please consider updating Boost Python.")
-						ENDIF()
-
-						SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Build/python/)
-						FILE(MAKE_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
-
-						FILE(GLOB SOURCES *.cc *hh)
-
-						INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS} ../)
-						LINK_DIRECTORIES(${Boost_LIBRARY_DIRS})
-
-						ADD_LIBRARY(openmesh SHARED ${SOURCES})
-
-						install(TARGETS openmesh DESTINATION ${ACG_PROJECT_LIBDIR}/python )
-
-						TARGET_LINK_LIBRARIES(
-							openmesh
-							OpenMeshCore
-							OpenMeshTools
-							${Boost_LIBRARIES}
-							${PYTHON_LIBRARIES}
-						)
-
-						SET_TARGET_PROPERTIES(
-							openmesh
-							PROPERTIES
-							PREFIX ""
-							DEBUG_POSTFIX ""
-							RELEASE_POSTFIX ""
-						)
-
-						IF(APPLE)
-							SET_TARGET_PROPERTIES(openmesh PROPERTIES SUFFIX ".so")
-							IF (NOT (CMAKE_MAJOR_VERSION LESS 3))
-								SET_TARGET_PROPERTIES(openmesh PROPERTIES MACOSX_RPATH TRUE)
-							ENDIF()
-						ENDIF()
-
-						IF(WIN32)
-							SET_TARGET_PROPERTIES(openmesh PROPERTIES SUFFIX ".pyd")
-							SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
-
-							SET(OUTPUTS openmesh.exp openmesh.lib openmesh.pyd)
-
-							FOREACH(FILE ${OUTPUTS})
-								ADD_CUSTOM_COMMAND(
-									TARGET openmesh POST_BUILD
-									COMMAND ${CMAKE_COMMAND} -E copy
-										${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${FILE}
-										${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
-								)
-							ENDFOREACH()
-						ENDIF()
-
-						IF(OPENMESH_BUILD_PYTHON_UNIT_TESTS)
-							SET(UNITTEST_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/Python-Unittests/)
-
-							# Copy unit tests
-							FILE(GLOB UNITTESTS Unittests/*.py)
-							FOREACH(TEST ${UNITTESTS})
-								FILE(COPY ${TEST} DESTINATION ${UNITTEST_OUTPUT_DIRECTORY})
-							ENDFOREACH()
-
-							# Copy test files
-							FILE(GLOB TESTFILES ${PROJECT_SOURCE_DIR}/src/Unittests/TestFiles/*(.off|.obj|.mtl|.stl|.ply|.om))
-							FOREACH(FILE ${TESTFILES})
-								FILE(COPY ${FILE} DESTINATION ${UNITTEST_OUTPUT_DIRECTORY})
-							ENDFOREACH()
-
-							# Copy library
-							IF(WIN32)
-								FOREACH(FILE ${OUTPUTS})
-									ADD_CUSTOM_COMMAND(
-										TARGET openmesh POST_BUILD
-										COMMAND ${CMAKE_COMMAND} -E copy
-											${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${FILE}
-											${UNITTEST_OUTPUT_DIRECTORY}
-									)
-								ENDFOREACH()
-							ELSE()
-								ADD_CUSTOM_COMMAND(
-									TARGET openmesh POST_BUILD
-									COMMAND ${CMAKE_COMMAND} -E copy
-										${CMAKE_BINARY_DIR}/Build/python/openmesh.so
-										${UNITTEST_OUTPUT_DIRECTORY}
-								)
-							ENDIF()
-
-							ADD_TEST(
-								NAME Python_tests
-								WORKING_DIRECTORY ${UNITTEST_OUTPUT_DIRECTORY}
-								COMMAND ${PYTHON_EXECUTABLE} -m unittest discover --verbose
-							)
-						ENDIF()
-
-					ELSE()
-						MESSAGE("Checking the Boost Python configuration failed!")
-						MESSAGE("Reason: An error occurred while running a small Boost Python test project.")
-						MESSAGE("Make sure that your Python and Boost Python libraries match.")
-						MESSAGE("Skipping Python Bindings.")
-					ENDIF()
-				ELSE()
-					MESSAGE("Checking the Boost Python configuration failed!")
-					MESSAGE("Reason: Python Interpreter ${PYTHONLIBS_VERSION_STRING} not found.")
-					MESSAGE("Skipping Python Bindings.")
-				ENDIF()
-			ELSE()
-				MESSAGE("Checking the Boost Python configuration failed!")
-				MESSAGE("Reason: Building a small Boost Python test project failed.")
-				MESSAGE("Make sure that your Python and Boost Python libraries match.")
-				MESSAGE("Skipping Python Bindings.")
-			ENDIF()
-		ELSE()
-			MESSAGE("Boost Python not found! Skipping Python Bindings.")
-		ENDIF()
-	ELSE()
-		MESSAGE("PythonLibs not found! Skipping Python Bindings.")
-	ENDIF()
-ENDIF()

src/Python/Circulator.hh

@@ -1,98 +0,0 @@
-#ifndef OPENMESH_PYTHON_CIRCULATOR_HH
-#define OPENMESH_PYTHON_CIRCULATOR_HH
-
-#include "Python/Bindings.hh"
-
-namespace OpenMesh {
-namespace Python {
-
-/**
- * Wrapper for circulators.
- *
- * This class template is used to wrap circulators for %Python. It implements
- * %Python's iterator protocol (the magic methods \_\_iter\_\_ and
- * \_\_next\_\_).
- *
- * @tparam Circulator A circulator type.
- */
-template<class Circulator, class CenterEntityHandle>
-class CirculatorWrapperT {
-	public:
-
-		/**
-		 * Constructor
-		 *
-		 * @param _mesh The mesh that contains the items to iterate over.
-		 * @param _center The handle to the center item.
-		 */
-		CirculatorWrapperT(PolyMesh& _mesh, CenterEntityHandle _center) :
-			circulator_(_mesh, _center) {
-		}
-
-		/**
-		 * Constructor
-		 *
-		 * @param _mesh The mesh that contains the items to iterate over.
-		 * @param _center The handle to the center item.
-		 */
-		CirculatorWrapperT(TriMesh& _mesh, CenterEntityHandle _center) :
-			circulator_(_mesh, _center) {
-		}
-
-		/**
-		 * Implementation of %Python's \_\_iter\_\_ magic method.
-		 *
-		 * @return This circulator.
-		 */
-		CirculatorWrapperT iter() const {
-			return *this;
-		}
-
-		/**
-		 * Implementation of %Python's \_\_next\_\_ magic method.
-		 *
-		 * @return The next item. Raises a %Python StopIteration exception if
-		 * there are no more items.
-		 */
-		typename Circulator::value_type next() {
-			if (circulator_.is_valid()) {
-				typename Circulator::value_type res = *circulator_;
-				++circulator_;
-				return res;
-			}
-			else {
-				PyErr_SetString(PyExc_StopIteration, "No more data.");
-				boost::python::throw_error_already_set();
-			}
-			return typename Circulator::value_type();
-		}
-
-	private:
-		Circulator circulator_;
-};
-
-/**
- * Expose a circulator type to %Python.
- *
- * @tparam Circulator A circulator type.
- *
- * @param _name The name of the circulator type to be exposed.
- *
- * @note Circulators are wrapped by CirculatorWrapperT before they are exposed
- * to %Python, i.e. they are not exposed directly. This means that circulators
- * that are passed from %Python to C++ are instances of CirculatorWrapperT.
- */
-template<class Circulator, class CenterEntityHandle>
-void expose_circulator(const char *_name) {
-	class_<CirculatorWrapperT<Circulator, CenterEntityHandle> >(_name, init<TriMesh&, CenterEntityHandle>())
-		.def(init<PolyMesh&, CenterEntityHandle>())
-		.def("__iter__", &CirculatorWrapperT<Circulator, CenterEntityHandle>::iter)
-		.def("__next__", &CirculatorWrapperT<Circulator, CenterEntityHandle>::next)
-		.def("next", &CirculatorWrapperT<Circulator, CenterEntityHandle>::next)
-		;
-}
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/Decimater.hh

@@ -1,297 +0,0 @@
-#ifndef OPENMESH_PYTHON_DECIMATER_HH
-#define OPENMESH_PYTHON_DECIMATER_HH
-
-#include "Python/Bindings.hh"
-#include "OpenMesh/Tools/Decimater/ModBaseT.hh"
-#include "OpenMesh/Tools/Decimater/ModAspectRatioT.hh"
-#include "OpenMesh/Tools/Decimater/ModEdgeLengthT.hh"
-#include "OpenMesh/Tools/Decimater/ModHausdorffT.hh"
-#include "OpenMesh/Tools/Decimater/ModIndependentSetsT.hh"
-#include "OpenMesh/Tools/Decimater/ModNormalDeviationT.hh"
-#include "OpenMesh/Tools/Decimater/ModNormalFlippingT.hh"
-#include "OpenMesh/Tools/Decimater/ModProgMeshT.hh"
-#include "OpenMesh/Tools/Decimater/ModQuadricT.hh"
-#include "OpenMesh/Tools/Decimater/ModRoundnessT.hh"
-#include "OpenMesh/Tools/Decimater/DecimaterT.hh"
-
-#include <cstdio>
-
-namespace OpenMesh {
-namespace Python {
-
-#define INIT_MESH_REF init<Mesh&>()[with_custodian_and_ward<1,2>()]
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(decimate_overloads, decimate, 0, 1)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(decimate_to_faces_overloads, decimate_to_faces, 0, 2)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_max_err_overloads, set_max_err, 1, 2)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_min_roundness_overloads, set_min_roundness, 1, 2)
-
-
-template <class Handle>
-void expose_module_handle(const char *_name) {
-	class_<Handle, boost::noncopyable>(_name)
-		.def("is_valid", &Handle::is_valid)
-		;
-}
-
-template <class Module>
-list infolist(Module& _self) {
-	const typename Module::InfoList& infos = _self.infolist();
-	list res;
-	for (size_t i = 0; i < infos.size(); ++i) {
-		res.append(infos[i]);
-	}
-	return res;
-}
-
-template <class Mesh>
-void expose_decimater(const char *_name) {
-
-	typedef Decimater::ModBaseT<Mesh> ModBase;
-	typedef Decimater::ModAspectRatioT<Mesh> ModAspectRatio;
-	typedef Decimater::ModEdgeLengthT<Mesh> ModEdgeLength;
-	typedef Decimater::ModHausdorffT<Mesh> ModHausdorff;
-	typedef Decimater::ModIndependentSetsT<Mesh> ModIndependentSets;
-	typedef Decimater::ModNormalDeviationT<Mesh> ModNormalDeviation;
-	typedef Decimater::ModNormalFlippingT<Mesh> ModNormalFlipping;
-	typedef Decimater::ModProgMeshT<Mesh> ModProgMesh;
-	typedef Decimater::ModQuadricT<Mesh> ModQuadric;
-	typedef Decimater::ModRoundnessT<Mesh> ModRoundness;
-
-	typedef Decimater::ModHandleT<ModAspectRatio> ModAspectRatioHandle;
-	typedef Decimater::ModHandleT<ModEdgeLength> ModEdgeLengthHandle;
-	typedef Decimater::ModHandleT<ModHausdorff> ModHausdorffHandle;
-	typedef Decimater::ModHandleT<ModIndependentSets> ModIndependentSetsHandle;
-	typedef Decimater::ModHandleT<ModNormalDeviation> ModNormalDeviationHandle;
-	typedef Decimater::ModHandleT<ModNormalFlipping> ModNormalFlippingHandle;
-	typedef Decimater::ModHandleT<ModProgMesh> ModProgMeshHandle;
-	typedef Decimater::ModHandleT<ModQuadric> ModQuadricHandle;
-	typedef Decimater::ModHandleT<ModRoundness> ModRoundnessHandle;
-
-	typedef Decimater::BaseDecimaterT<Mesh> BaseDecimater;
-	typedef Decimater::DecimaterT<Mesh> Decimater;
-
-	typedef typename ModProgMesh::Info Info;
-	typedef std::vector<Info> InfoList;
-
-	bool (BaseDecimater::*add1)(ModAspectRatioHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add2)(ModEdgeLengthHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add3)(ModHausdorffHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add4)(ModIndependentSetsHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add5)(ModNormalDeviationHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add6)(ModNormalFlippingHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add7)(ModProgMeshHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add8)(ModQuadricHandle&) = &Decimater::add;
-	bool (BaseDecimater::*add9)(ModRoundnessHandle&) = &Decimater::add;
-
-	bool (BaseDecimater::*remove1)(ModAspectRatioHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove2)(ModEdgeLengthHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove3)(ModHausdorffHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove4)(ModIndependentSetsHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove5)(ModNormalDeviationHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove6)(ModNormalFlippingHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove7)(ModProgMeshHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove8)(ModQuadricHandle&) = &Decimater::remove;
-	bool (BaseDecimater::*remove9)(ModRoundnessHandle&) = &Decimater::remove;
-
-	ModAspectRatio& (BaseDecimater::*module1)(ModAspectRatioHandle&) = &Decimater::module;
-	ModEdgeLength& (BaseDecimater::*module2)(ModEdgeLengthHandle&) = &Decimater::module;
-	ModHausdorff& (BaseDecimater::*module3)(ModHausdorffHandle&) = &Decimater::module;
-	ModIndependentSets& (BaseDecimater::*module4)(ModIndependentSetsHandle&) = &Decimater::module;
-	ModNormalDeviation& (BaseDecimater::*module5)(ModNormalDeviationHandle&) = &Decimater::module;
-	ModNormalFlipping& (BaseDecimater::*module6)(ModNormalFlippingHandle&) = &Decimater::module;
-	ModProgMesh& (BaseDecimater::*module7)(ModProgMeshHandle&) = &Decimater::module;
-	ModQuadric& (BaseDecimater::*module8)(ModQuadricHandle&) = &Decimater::module;
-	ModRoundness& (BaseDecimater::*module9)(ModRoundnessHandle&) = &Decimater::module;
-
-	// Decimater
-	// ----------------------------------------
-
-	char buffer[64];
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "Decimater");
-
-	class_<Decimater, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("decimate", &Decimater::decimate, decimate_overloads())
-		.def("decimate_to", &Decimater::decimate_to)
-		.def("decimate_to_faces", &Decimater::decimate_to_faces, decimate_to_faces_overloads())
-
-		.def("initialize", &Decimater::initialize)
-		.def("is_initialized", &Decimater::is_initialized)
-
-		.def("add", add1)
-		.def("add", add2)
-		.def("add", add3)
-		.def("add", add4)
-		.def("add", add5)
-		.def("add", add6)
-		.def("add", add7)
-		.def("add", add8)
-		.def("add", add9)
-
-		.def("remove", remove1)
-		.def("remove", remove2)
-		.def("remove", remove3)
-		.def("remove", remove4)
-		.def("remove", remove5)
-		.def("remove", remove6)
-		.def("remove", remove7)
-		.def("remove", remove8)
-		.def("remove", remove9)
-
-		.def("module", module1, return_value_policy<reference_existing_object>())
-		.def("module", module2, return_value_policy<reference_existing_object>())
-		.def("module", module3, return_value_policy<reference_existing_object>())
-		.def("module", module4, return_value_policy<reference_existing_object>())
-		.def("module", module5, return_value_policy<reference_existing_object>())
-		.def("module", module6, return_value_policy<reference_existing_object>())
-		.def("module", module7, return_value_policy<reference_existing_object>())
-		.def("module", module8, return_value_policy<reference_existing_object>())
-		.def("module", module9, return_value_policy<reference_existing_object>())
-		;
-
-	// ModBase
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModBase");
-
-	class_<ModBase, boost::noncopyable>(buffer, no_init)
-		.def("name", &ModBase::name, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("is_binary", &ModBase::is_binary)
-		.def("set_binary", &ModBase::set_binary)
-		.def("initialize", &ModBase::initialize) // TODO VIRTUAL
-		.def("collapse_priority", &ModBase::collapse_priority) // TODO VIRTUAL
-		.def("preprocess_collapse", &ModBase::preprocess_collapse) // TODO VIRTUAL
-		.def("postprocess_collapse", &ModBase::postprocess_collapse) // TODO VIRTUAL
-		.def("set_error_tolerance_factor", &ModBase::set_error_tolerance_factor) // TODO VIRTUAL
-		;
-
-	// ModAspectRatio
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModAspectRatio");
-
-	class_<ModAspectRatio, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("aspect_ratio", &ModAspectRatio::aspect_ratio)
-		.def("set_aspect_ratio", &ModAspectRatio::set_aspect_ratio)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModAspectRatioHandle");
-	expose_module_handle<ModAspectRatioHandle>(buffer);
-
-	// ModEdgeLength
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModEdgeLength");
-
-	class_<ModEdgeLength, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("edge_length", &ModEdgeLength::edge_length)
-		.def("set_edge_length", &ModEdgeLength::set_edge_length)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModEdgeLengthHandle");
-	expose_module_handle<ModEdgeLengthHandle>(buffer);
-
-	// ModHausdorff
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModHausdorff");
-
-	class_<ModHausdorff, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("tolerance", &ModHausdorff::tolerance)
-		.def("set_tolerance", &ModHausdorff::set_tolerance)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModHausdorffHandle");
-	expose_module_handle<ModHausdorffHandle>(buffer);
-
-	// ModIndependentSets
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModIndependentSets");
-
-	class_<ModIndependentSets, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF);
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModIndependentSetsHandle");
-	expose_module_handle<ModIndependentSetsHandle>(buffer);
-
-	// ModNormalDeviation
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalDeviation");
-
-	class_<ModNormalDeviation, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("normal_deviation", &ModNormalDeviation::normal_deviation)
-		.def("set_normal_deviation", &ModNormalDeviation::set_normal_deviation)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalDeviationHandle");
-	expose_module_handle<ModNormalDeviationHandle>(buffer);
-
-	// ModNormalFlipping
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalFlipping");
-
-	class_<ModNormalFlipping, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("max_normal_deviation", &ModNormalFlipping::max_normal_deviation)
-		.def("set_max_normal_deviation", &ModNormalFlipping::set_max_normal_deviation)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalFlippingHandle");
-	expose_module_handle<ModNormalFlippingHandle>(buffer);
-
-	// ModProgMesh
-	// ----------------------------------------
-
-	class_<Info>("Info", no_init)
-		.def_readwrite("v0", &Info::v0)
-		.def_readwrite("v1", &Info::v1)
-		.def_readwrite("vl", &Info::vl)
-		.def_readwrite("vr", &Info::vr)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModProgMesh");
-
-	class_<ModProgMesh, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("pmi", &infolist<ModProgMesh>)
-		.def("infolist", &infolist<ModProgMesh>)
-		.def("write", &ModProgMesh::write)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModProgMeshHandle");
-	expose_module_handle<ModProgMeshHandle>(buffer);
-
-	// ModQuadric
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModQuadric");
-
-	class_<ModQuadric, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("set_max_err", &ModQuadric::set_max_err, set_max_err_overloads())
-		.def("unset_max_err", &ModQuadric::unset_max_err)
-		.def("max_err", &ModQuadric::max_err)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModQuadricHandle");
-	expose_module_handle<ModQuadricHandle>(buffer);
-
-	// ModRoundness
-	// ----------------------------------------
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModRoundness");
-
-	class_<ModRoundness, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
-		.def("set_min_angle", &ModRoundness::set_min_angle)
-		.def("set_min_roundness", &ModRoundness::set_min_roundness, set_min_roundness_overloads())
-		.def("unset_min_roundness", &ModRoundness::unset_min_roundness)
-		.def("roundness", &ModRoundness::roundness)
-		;
-
-	snprintf(buffer, sizeof buffer, "%s%s", _name, "ModRoundnessHandle");
-	expose_module_handle<ModRoundnessHandle>(buffer);
-}
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/Example/CMakeLists.txt

@@ -1,30 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-PROJECT(Example)
-
-FILE(GLOB SOURCES *.cc *hh)
-
-INCLUDE_DIRECTORIES(${INCLUDE_DIRECTORIES})
-LINK_DIRECTORIES(${LINK_DIRECTORIES})
-
-ADD_LIBRARY(example SHARED ${SOURCES})
-TARGET_LINK_LIBRARIES(example ${LINK_LIBRARIES})
-
-SET_TARGET_PROPERTIES(
-	example
-	PROPERTIES
-	PREFIX ""
-	DEBUG_POSTFIX ""
-	RELEASE_POSTFIX ""
-)
-
-IF(APPLE)
-	SET_TARGET_PROPERTIES(example PROPERTIES SUFFIX ".so")
-	IF (NOT (CMAKE_MAJOR_VERSION LESS 3))
-		SET_TARGET_PROPERTIES(example PROPERTIES MACOSX_RPATH TRUE)
-	ENDIF()
-ENDIF()
-
-IF(WIN32)
-	SET_TARGET_PROPERTIES(example PROPERTIES SUFFIX ".pyd")
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
-ENDIF()

src/Python/Example/Example.cc

@@ -1,22 +0,0 @@
-#include <boost/python.hpp>
-
-char const * greet() {
-	return "hello, world";
-}
-
-struct World {
-	void set(std::string msg) { this->msg = msg; }
-	std::string greet() { return msg; }
-	std::string msg;
-};
-
-BOOST_PYTHON_MODULE(example) {
-	using namespace boost::python;
-	
-	def("greet", greet);
-	
-	class_<World>("World")
-		.def("greet", &World::greet)
-		.def("set", &World::set)
-	;
-}

src/Python/InputOutput.hh

@@ -1,115 +0,0 @@
-#ifndef OPENMESH_PYTHON_INPUTOUTPUT_HH
-#define OPENMESH_PYTHON_INPUTOUTPUT_HH
-
-#include "Python/Bindings.hh"
-
-namespace OpenMesh {
-namespace Python {
-
-const IO::Options::Flag FLAG_DEFAULT        = IO::Options::Default;
-const IO::Options::Flag FLAG_BINARY         = IO::Options::Binary;
-const IO::Options::Flag FLAG_MSB            = IO::Options::MSB;
-const IO::Options::Flag FLAG_LSB            = IO::Options::LSB;
-const IO::Options::Flag FLAG_SWAP           = IO::Options::Swap;
-const IO::Options::Flag FLAG_VERTEXNORMAL   = IO::Options::VertexNormal;
-const IO::Options::Flag FLAG_VERTEXCOLOR    = IO::Options::VertexColor;
-const IO::Options::Flag FLAG_VERTEXTEXCOORD = IO::Options::VertexTexCoord;
-const IO::Options::Flag FLAG_EDGECOLOR      = IO::Options::EdgeColor;
-const IO::Options::Flag FLAG_FACENORMAL     = IO::Options::FaceNormal;
-const IO::Options::Flag FLAG_FACECOLOR      = IO::Options::FaceColor;
-const IO::Options::Flag FLAG_FACETEXCOORD   = IO::Options::FaceTexCoord;
-const IO::Options::Flag FLAG_COLORALPHA     = IO::Options::ColorAlpha;
-const IO::Options::Flag FLAG_COLORFLOAT     = IO::Options::ColorFloat;
-
-BOOST_PYTHON_FUNCTION_OVERLOADS(read_mesh_overloads, IO::read_mesh, 3, 4)
-BOOST_PYTHON_FUNCTION_OVERLOADS(write_mesh_overloads, IO::write_mesh, 2, 4)
-
-/**
- * Expose the input/output functions and options to Python.
- */
-void expose_io() {
-
-	//======================================================================
-	//  Functions
-	//======================================================================
-
-	bool (*read_mesh_poly        )(PolyMesh&, const std::string&                    ) = &IO::read_mesh;
-	bool (*read_mesh_poly_options)(PolyMesh&, const std::string&, IO::Options&, bool) = &IO::read_mesh;
-	bool (*read_mesh_tri         )(TriMesh&,  const std::string&                    ) = &IO::read_mesh;
-	bool (*read_mesh_tri_options )(TriMesh&,  const std::string&, IO::Options&, bool) = &IO::read_mesh;
-
-	bool (*write_mesh_poly)(const PolyMesh&, const std::string&, IO::Options, std::streamsize) = &IO::write_mesh;
-	bool (*write_mesh_tri )(const TriMesh&,  const std::string&, IO::Options, std::streamsize) = &IO::write_mesh;
-
-	def("read_mesh", read_mesh_poly);
-	def("read_mesh", read_mesh_poly_options, read_mesh_overloads());
-	def("read_mesh", read_mesh_tri);
-	def("read_mesh", read_mesh_tri_options, read_mesh_overloads());
-
-	def("write_mesh", write_mesh_poly, write_mesh_overloads());
-	def("write_mesh", write_mesh_tri, write_mesh_overloads());
-
-	//======================================================================
-	//  Options
-	//======================================================================
-
-	scope scope_options = class_<IO::Options>("Options")
-		.def(init<IO::Options::Flag>())
-		.def("cleanup", &IO::Options::cleanup)
-		.def("clear", &IO::Options::clear)
-		.def("is_empty", &IO::Options::is_empty)
-		.def("check", &IO::Options::check)
-		.def("is_binary", &IO::Options::is_binary)
-		.def("vertex_has_normal", &IO::Options::vertex_has_normal)
-		.def("vertex_has_color", &IO::Options::vertex_has_color)
-		.def("vertex_has_texcoord", &IO::Options::vertex_has_texcoord)
-		.def("edge_has_color", &IO::Options::edge_has_color)
-		.def("face_has_normal", &IO::Options::face_has_normal)
-		.def("face_has_color", &IO::Options::face_has_color)
-		.def("face_has_texcoord", &IO::Options::face_has_texcoord)
-		.def("color_has_alpha", &IO::Options::color_has_alpha)
-		.def("color_is_float", &IO::Options::color_is_float)
-
-		.def(self == self)
-		.def(self != self)
-		.def(self -= IO::Options::Flag())
-		.def(self += IO::Options::Flag())
-
-		.def_readonly("Default", &FLAG_DEFAULT)
-		.def_readonly("Binary", &FLAG_BINARY)
-		.def_readonly("MSB", &FLAG_MSB)
-		.def_readonly("LSB", &FLAG_LSB)
-		.def_readonly("Swap", &FLAG_SWAP)
-		.def_readonly("VertexNormal", &FLAG_VERTEXNORMAL)
-		.def_readonly("VertexColor", &FLAG_VERTEXCOLOR)
-		.def_readonly("VertexTexCoord", &FLAG_VERTEXTEXCOORD)
-		.def_readonly("EdgeColor", &FLAG_EDGECOLOR)
-		.def_readonly("FaceNormal", &FLAG_FACENORMAL)
-		.def_readonly("FaceColor", &FLAG_FACECOLOR)
-		.def_readonly("FaceTexCoord", &FLAG_FACETEXCOORD)
-		.def_readonly("ColorAlpha", &FLAG_COLORALPHA)
-		.def_readonly("ColorFloat", &FLAG_COLORFLOAT)
-		;
-
-	enum_<IO::Options::Flag>("Flag")
-		.value("Default", IO::Options::Default)
-		.value("Binary", IO::Options::Binary)
-		.value("MSB", IO::Options::MSB)
-		.value("LSB", IO::Options::LSB)
-		.value("Swap", IO::Options::Swap)
-		.value("VertexNormal", IO::Options::VertexNormal)
-		.value("VertexColor", IO::Options::VertexColor)
-		.value("VertexTexCoord", IO::Options::VertexTexCoord)
-		.value("EdgeColor", IO::Options::EdgeColor)
-		.value("FaceNormal", IO::Options::FaceNormal)
-		.value("FaceColor", IO::Options::FaceColor)
-		.value("FaceTexCoord", IO::Options::FaceTexCoord)
-		.value("ColorAlpha", IO::Options::ColorAlpha)
-		.value("ColorFloat", IO::Options::ColorFloat)
-		;
-}
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/Iterator.hh

@@ -1,121 +0,0 @@
-#ifndef OPENMESH_PYTHON_ITERATOR_HH
-#define OPENMESH_PYTHON_ITERATOR_HH
-
-#include "Python/Bindings.hh"
-
-namespace OpenMesh {
-namespace Python {
-
-/**
- * Wrapper for mesh item iterators.
- *
- * This class template is used to wrap mesh item iterators for %Python. It
- * implements %Python's iterator protocol (the magic methods \_\_iter\_\_ and
- * \_\_next\_\_).
- *
- * @tparam Iterator An iterator type.
- * @tparam n_items A member function pointer that points to the mesh function
- * that returns the number of items to iterate over (e.g. n_vertices).
- */
-template<class Iterator, size_t (OpenMesh::ArrayKernel::*n_items)() const>
-class IteratorWrapperT {
-	public:
-
-		/**
-		 * Constructor
-		 *
-		 * @param _mesh The mesh that contains the items to iterate over.
-		 * @param _hnd The handle of the first item to iterate over.
-		 * @param _skip Specifies if deleted/hidden elements are skipped.
-		 */
-		IteratorWrapperT(const PolyMesh& _mesh, typename Iterator::value_type _hnd, bool _skip = false) :
-			mesh_(_mesh), n_items_(n_items),
-			iterator_(_mesh, _hnd, _skip),
-			iterator_end_(_mesh, typename Iterator::value_type(int((_mesh.*n_items)()))) {
-		}
-
-		/**
-		 * Constructor
-		 *
-		 * @param _mesh The mesh that contains the items to iterate over.
-		 * @param _hnd The handle of the first item to iterate over.
-		 * @param _skip Specifies if deleted/hidden elements are skipped.
-		 */
-		IteratorWrapperT(const TriMesh& _mesh, typename Iterator::value_type _hnd, bool _skip = false) :
-			mesh_(_mesh), n_items_(n_items),
-			iterator_(_mesh, _hnd, _skip),
-			iterator_end_(_mesh, typename Iterator::value_type(int((_mesh.*n_items)()))) {
-		}
-
-		/**
-		 * Implementation of %Python's \_\_iter\_\_ magic method.
-		 *
-		 * @return This iterator.
-		 */
-		IteratorWrapperT iter() const {
-			return *this;
-		}
-
-		/**
-		 * Implementation of %Python's \_\_next\_\_ magic method.
-		 *
-		 * @return The next item. Raises a %Python StopIteration exception if
-		 * there are no more items.
-		 */
-		typename Iterator::value_type next() {
-			if (iterator_ != iterator_end_) {
-				typename Iterator::value_type res = *iterator_;
-				++iterator_;
-				return res;
-			}
-			else {
-				PyErr_SetString(PyExc_StopIteration, "No more data.");
-				boost::python::throw_error_already_set();
-			}
-			return typename Iterator::value_type();
-		}
-
-		/**
-		 * Implementation of %Python's \_\_len\_\_ magic method.
-		 *
-		 * @return The number of items in the mesh.
-		 */
-		unsigned int len() const {
-			return (mesh_.*n_items_)();
-		}
-
-	private:
-		const OpenMesh::PolyConnectivity& mesh_;
-		size_t (OpenMesh::ArrayKernel::*n_items_)() const;
-		Iterator iterator_;
-		Iterator iterator_end_;
-};
-
-/**
- * Expose an iterator type to %Python.
- *
- * @tparam Iterator An iterator type.
- * @tparam n_items A member function pointer that points to the mesh function
- * that returns the number of items to iterate over (e.g. n_vertices).
- *
- * @param _name The name of the iterator type to be exposed.
- *
- * @note %Iterators are wrapped by IteratorWrapperT before they are exposed to
- * %Python, i.e. they are not exposed directly. This means that iterators
- * that are passed from %Python to C++ are instances of IteratorWrapperT.
- */
-template<class Iterator, size_t (OpenMesh::ArrayKernel::*n_items)() const>
-void expose_iterator(const char *_name) {
-	class_<IteratorWrapperT<Iterator, n_items> >(_name, init<PolyMesh&, typename Iterator::value_type, optional<bool> >())
-		.def(init<TriMesh&, typename Iterator::value_type, optional<bool> >())
-		.def("__iter__", &IteratorWrapperT<Iterator, n_items>::iter)
-		.def("__next__", &IteratorWrapperT<Iterator, n_items>::next)
-		.def("__len__", &IteratorWrapperT<Iterator, n_items>::len)
-		.def("next", &IteratorWrapperT<Iterator, n_items>::next)
-		;
-}
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/Mesh.hh

@@ -1,931 +0,0 @@
-#ifndef OPENMESH_PYTHON_MESH_HH
-#define OPENMESH_PYTHON_MESH_HH
-
-#include "Python/Bindings.hh"
-#include "Python/Iterator.hh"
-#include "Python/Circulator.hh"
-
-#include <boost/python/stl_iterator.hpp>
-
-namespace OpenMesh {
-namespace Python {
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(garbage_collection_overloads, garbage_collection, 0, 3)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(add_property_overloads, add_property, 1, 2)
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(copy_all_properties_overloads, copy_all_properties, 2, 3)
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(delete_vertex_overloads, delete_vertex, 1, 2)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(delete_edge_overloads, delete_edge, 1, 2)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(delete_face_overloads, delete_face, 1, 2)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(is_boundary_overloads, is_boundary, 1, 2)
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(find_feature_edges_overloads, find_feature_edges, 0, 1)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(update_normal_overloads, update_normal, 1, 2)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(update_halfedge_normals_overloads, update_halfedge_normals, 0, 1)
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(calc_halfedge_normal_overloads, calc_halfedge_normal, 1, 2)
-
-/**
- * Set the status of an item.
- *
- * @tparam Mesh A mesh type.
- * @tparam PropHandle A handle type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _h The handle of the item whose status is to be set.
- * @param _info The status to be set.
- *
- * Depending on @ref OPENMESH_PYTHON_DEFAULT_POLICY, Mesh::status may
- * return by value instead of reference. This function ensures that the
- * status of an item can be changed nonetheless.
- */
-template <class Mesh, class IndexHandle>
-void set_status(Mesh& _self, IndexHandle _h, const OpenMesh::Attributes::StatusInfo& _info) {
-	_self.status(_h) = _info;
-}
-
-/**
- * Set the value of a property of an item.
- *
- * @tparam Mesh A mesh type.
- * @tparam PropHandle A property handle type.
- * @tparam IndexHandle The appropriate handle type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _ph The property that is to be set.
- * @param _h The handle of the item whose property is to be set.
- * @param _value The value to be set.
- *
- * Depending on @ref OPENMESH_PYTHON_DEFAULT_POLICY, Mesh::property may
- * return by value instead of reference. This function ensures that the
- * property value of an item can be changed nonetheless.
- */
-template <class Mesh, class PropHandle, class IndexHandle>
-void set_property(Mesh& _self, PropHandle _ph, IndexHandle _h, const object& _value) {
-	_self.property(_ph, _h) = _value;
-}
-
-/**
- * Set the value of a mesh property.
- *
- * @tparam Mesh A mesh type.
- * @tparam PropHandle A property handle type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _ph The property that is to be set.
- * @param _value The value to be set.
- *
- * Depending on @ref OPENMESH_PYTHON_DEFAULT_POLICY, Mesh::property may
- * return by value instead of reference. This function ensures that the
- * property value of an item can be changed nonetheless.
- */
-template <class Mesh, class PropHandle>
-void set_property(Mesh& _self, PropHandle _ph, const object& _value) {
-	_self.property(_ph) = _value;
-}
-
-/**
- * Thin wrapper for assign_connectivity.
- *
- * @tparam Mesh A mesh type.
- * @tparam OtherMesh A mesh type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _other The mesh from which the connectivity is to be copied.
- */
-template <class Mesh, class OtherMesh>
-void assign_connectivity(Mesh& _self, const OtherMesh& _other) {
-	_self.assign_connectivity(_other);
-}
-
-/**
- * Get an iterator.
- */
-template <class Mesh, class Iterator, size_t (ArrayKernel::*n_items)() const>
-IteratorWrapperT<Iterator, n_items> get_iterator(Mesh& _self) {
-	return IteratorWrapperT<Iterator, n_items>(_self, typename Iterator::value_type(0));
-}
-
-/**
- * Get a skipping iterator.
- */
-template <class Mesh, class Iterator, size_t (ArrayKernel::*n_items)() const>
-IteratorWrapperT<Iterator, n_items> get_skipping_iterator(Mesh& _self) {
-	return IteratorWrapperT<Iterator, n_items>(_self, typename Iterator::value_type(0), true);
-}
-
-/**
- * Get a circulator.
- *
- * @tparam Mesh A Mesh type.
- * @tparam Circulator A circulator type.
- * @tparam CenterEntityHandle The appropriate handle type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _handle The handle of the item to circulate around.
- */
-template <class Mesh, class Circulator, class CenterEntityHandle>
-CirculatorWrapperT<Circulator, CenterEntityHandle> get_circulator(Mesh& _self, CenterEntityHandle _handle) {
-	return CirculatorWrapperT<Circulator, CenterEntityHandle>(_self, _handle);
-}
-
-/**
- * Garbage collection using lists instead of vectors to keep track of a set of
- * handles.
- *
- * @tparam Mesh A Mesh type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _vh_to_update The list of vertex handles to be updated.
- * @param _hh_to_update The list of halfedge handles to be updated.
- * @param _fh_to_update The list of face handles to be updated.
- * @param _v Remove deleted vertices?
- * @param _e Remove deleted edges?
- * @param _f Remove deleted faces?
- */
-template <class Mesh>
-void garbage_collection(Mesh& _self, list& _vh_to_update, list& _hh_to_update, list& _fh_to_update, bool _v = true, bool _e = true, bool _f = true) {
-	// Convert list of handles to vector of pointers
-	stl_input_iterator<VertexHandle*> vh_begin(_vh_to_update);
-	stl_input_iterator<VertexHandle*> vh_end;
-	std::vector<VertexHandle*> vh_vector;
-	vh_vector.insert(vh_vector.end(), vh_begin, vh_end);
-
-	// Convert list of handles to vector of pointers
-	stl_input_iterator<HalfedgeHandle*> hh_begin(_hh_to_update);
-	stl_input_iterator<HalfedgeHandle*> hh_end;
-	std::vector<HalfedgeHandle*> hh_vector;
-	hh_vector.insert(hh_vector.end(), hh_begin, hh_end);
-
-	// Convert list of handles to vector of pointers
-	stl_input_iterator<FaceHandle*> fh_begin(_fh_to_update);
-	stl_input_iterator<FaceHandle*> fh_end;
-	std::vector<FaceHandle*> fh_vector;
-	fh_vector.insert(fh_vector.end(), fh_begin, fh_end);
-
-	// Call garbage collection
-	_self.garbage_collection(vh_vector, hh_vector, fh_vector, _v, _e, _f);
-}
-
-/**
- * Add a new face from a %Python list of vertex handles.
- *
- * @tparam Mesh A Mesh type.
- *
- * @param _self The mesh instance that is to be used.
- * @param _vhandles The list of vertex handles.
- */
-template<class Mesh>
-FaceHandle add_face(Mesh& _self, const list& _vhandles) {
-	stl_input_iterator<VertexHandle> begin(_vhandles);
-	stl_input_iterator<VertexHandle> end;
-
-	std::vector<VertexHandle> vector;
-	vector.insert(vector.end(), begin, end);
-
-	return _self.add_face(vector);
-}
-
-/**
- * This function template is used to expose mesh member functions that are only
- * available for a specific type of mesh (i.e. they are available for polygon
- * meshes or triangle meshes, but not both).
- *
- * @tparam Class A boost::python::class type.
- *
- * @param _class The boost::python::class instance for which the member
- * functions are to be defined.
- */
-template <class Class>
-void expose_type_specific_functions(Class& _class) {
-	// See the template specializations below
-}
-
-/**
- * Function template specialization for polygon meshes.
- */
-template <>
-void expose_type_specific_functions(class_<PolyMesh>& _class) {
-	typedef PolyMesh::Scalar Scalar;
-	typedef PolyMesh::Point  Point;
-	typedef PolyMesh::Normal Normal;
-	typedef PolyMesh::Color  Color;
-
-	FaceHandle (PolyMesh::*add_face_3_vh)(VertexHandle, VertexHandle, VertexHandle              ) = &PolyMesh::add_face;
-	FaceHandle (PolyMesh::*add_face_4_vh)(VertexHandle, VertexHandle, VertexHandle, VertexHandle) = &PolyMesh::add_face;
-	FaceHandle (*add_face_list)(PolyMesh&, const list&) = &add_face;
-
-	void (PolyMesh::*split_eh_pt)(EdgeHandle, const Point&) = &PolyMesh::split;
-	void (PolyMesh::*split_eh_vh)(EdgeHandle, VertexHandle) = &PolyMesh::split;
-	void (PolyMesh::*split_fh_pt)(FaceHandle, const Point&) = &PolyMesh::split;
-	void (PolyMesh::*split_fh_vh)(FaceHandle, VertexHandle) = &PolyMesh::split;
-
-	Normal (PolyMesh::*calc_face_normal_pt)(const Point&, const Point&, const Point&) const = &PolyMesh::calc_face_normal;
-
-	_class
-		.def("add_face", add_face_3_vh)
-		.def("add_face", add_face_4_vh)
-		.def("add_face", add_face_list)
-
-		.def("split", split_eh_pt)
-		.def("split", split_eh_vh)
-		.def("split", split_fh_pt)
-		.def("split", split_fh_vh)
-
-		.def("split_copy", &PolyMesh::split_copy)
-
-		.def("calc_face_normal", calc_face_normal_pt)
-
-		.def("insert_edge", &PolyMesh::insert_edge)
-		;
-}
-
-/**
- * Function template specialization for triangle meshes.
- */
-template <>
-void expose_type_specific_functions(class_<TriMesh>& _class) {
-	typedef TriMesh::Scalar Scalar;
-	typedef TriMesh::Point  Point;
-	typedef TriMesh::Normal Normal;
-	typedef TriMesh::Color  Color;
-
-	FaceHandle (TriMesh::*add_face_3_vh)(VertexHandle, VertexHandle, VertexHandle) = &TriMesh::add_face;
-	FaceHandle (*add_face_list)(TriMesh&, const list&) = &add_face;
-
-	VertexHandle (TriMesh::*split_eh_pt)(EdgeHandle, const Point&) = &TriMesh::split;
-	void         (TriMesh::*split_eh_vh)(EdgeHandle, VertexHandle) = &TriMesh::split;
-	VertexHandle (TriMesh::*split_fh_pt)(FaceHandle, const Point&) = &TriMesh::split;
-	void         (TriMesh::*split_fh_vh)(FaceHandle, VertexHandle) = &TriMesh::split;
-
-	VertexHandle (TriMesh::*split_copy_eh_pt)(EdgeHandle, const Point&) = &TriMesh::split_copy;
-	void         (TriMesh::*split_copy_eh_vh)(EdgeHandle, VertexHandle) = &TriMesh::split_copy;
-	VertexHandle (TriMesh::*split_copy_fh_pt)(FaceHandle, const Point&) = &TriMesh::split_copy;
-	void         (TriMesh::*split_copy_fh_vh)(FaceHandle, VertexHandle) = &TriMesh::split_copy;
-
-	HalfedgeHandle (TriMesh::*vertex_split_pt)(Point,        VertexHandle, VertexHandle, VertexHandle) = &TriMesh::vertex_split;
-	HalfedgeHandle (TriMesh::*vertex_split_vh)(VertexHandle, VertexHandle, VertexHandle, VertexHandle) = &TriMesh::vertex_split;
-
-	_class
-		.def("add_face", add_face_3_vh)
-		.def("add_face", add_face_list)
-
-		.def("split", split_eh_pt)
-		.def("split", split_eh_vh)
-		.def("split", split_fh_pt)
-		.def("split", split_fh_vh)
-
-		.def("split_copy", split_copy_eh_pt)
-		.def("split_copy", split_copy_eh_vh)
-		.def("split_copy", split_copy_fh_pt)
-		.def("split_copy", split_copy_fh_vh)
-
-		.def("opposite_vh", &TriMesh::opposite_vh)
-		.def("opposite_he_opposite_vh", &TriMesh::opposite_he_opposite_vh)
-
-		.def("vertex_split", vertex_split_pt)
-		.def("vertex_split", vertex_split_vh)
-
-		.def("is_flip_ok", &TriMesh::is_flip_ok)
-		.def("flip", &TriMesh::flip)
-		;
-}
-
-
-/**
- * Expose a mesh type to %Python.
- *
- * @tparam Mesh A mesh type.
- *
- * @param _name The name of the mesh type to be exposed.
- */
-template <class Mesh>
-void expose_mesh(const char *_name) {
-	using OpenMesh::Attributes::StatusInfo;
-
-	typedef typename Mesh::Scalar Scalar;
-	typedef typename Mesh::Point  Point;
-	typedef typename Mesh::Normal Normal;
-	typedef typename Mesh::Color  Color;
-
-	//======================================================================
-	//  KernelT Function Pointers
-	//======================================================================
-
-	// Get the i'th item
-	VertexHandle   (Mesh::*vertex_handle_uint  )(unsigned int) const = &Mesh::vertex_handle;
-	HalfedgeHandle (Mesh::*halfedge_handle_uint)(unsigned int) const = &Mesh::halfedge_handle;
-	EdgeHandle     (Mesh::*edge_handle_uint    )(unsigned int) const = &Mesh::edge_handle;
-	FaceHandle     (Mesh::*face_handle_uint    )(unsigned int) const = &Mesh::face_handle;
-
-	// Delete items
-	void (Mesh::*garbage_collection_bools)(bool, bool, bool) = &Mesh::garbage_collection;
-	void (*garbage_collection_lists_bools)(Mesh&, list&, list&, list&, bool, bool, bool) = &garbage_collection;
-
-	// Vertex connectivity
-	HalfedgeHandle (Mesh::*halfedge_handle_vh)(VertexHandle) const = &Mesh::halfedge_handle;
-	HalfedgeHandle (Mesh::*halfedge_handle_fh)(FaceHandle  ) const = &Mesh::halfedge_handle;
-
-	// Halfedge connectivity
-	FaceHandle     (Mesh::*face_handle_hh         )(HalfedgeHandle) const = &Mesh::face_handle;
-	HalfedgeHandle (Mesh::*prev_halfedge_handle_hh)(HalfedgeHandle) const = &Mesh::prev_halfedge_handle;
-	EdgeHandle     (Mesh::*edge_handle_hh         )(HalfedgeHandle) const = &Mesh::edge_handle;
-
-	// Edge connectivity
-	HalfedgeHandle (Mesh::*halfedge_handle_eh_uint)(EdgeHandle, unsigned int) const = &Mesh::halfedge_handle;
-
-	// Set halfedge
-	void (Mesh::*set_halfedge_handle_vh_hh)(VertexHandle, HalfedgeHandle) = &Mesh::set_halfedge_handle;
-	void (Mesh::*set_halfedge_handle_fh_hh)(FaceHandle, HalfedgeHandle  ) = &Mesh::set_halfedge_handle;
-
-	// Handle -> Item
-	const typename Mesh::Vertex&   (Mesh::*vertex  )(VertexHandle  ) const = &Mesh::vertex;
-	const typename Mesh::Halfedge& (Mesh::*halfedge)(HalfedgeHandle) const = &Mesh::halfedge;
-	const typename Mesh::Edge&     (Mesh::*edge    )(EdgeHandle    ) const = &Mesh::edge;
-	const typename Mesh::Face&     (Mesh::*face    )(FaceHandle    ) const = &Mesh::face;
-
-	// Item -> Handle
-	VertexHandle   (Mesh::*handle_v)(const typename Mesh::Vertex&  ) const = &Mesh::handle;
-	HalfedgeHandle (Mesh::*handle_h)(const typename Mesh::Halfedge&) const = &Mesh::handle;
-	EdgeHandle     (Mesh::*handle_e)(const typename Mesh::Edge&    ) const = &Mesh::handle;
-	FaceHandle     (Mesh::*handle_f)(const typename Mesh::Face&    ) const = &Mesh::handle;
-
-	// Get value of a standard property (point, normal, color)
-	const typename Mesh::Point&  (Mesh::*point_vh )(VertexHandle  ) const = &Mesh::point;
-	const typename Mesh::Normal& (Mesh::*normal_vh)(VertexHandle  ) const = &Mesh::normal;
-	const typename Mesh::Normal& (Mesh::*normal_hh)(HalfedgeHandle) const = &Mesh::normal;
-	const typename Mesh::Normal& (Mesh::*normal_fh)(FaceHandle    ) const = &Mesh::normal;
-	const typename Mesh::Color&  (Mesh::*color_vh )(VertexHandle  ) const = &Mesh::color;
-	const typename Mesh::Color&  (Mesh::*color_hh )(HalfedgeHandle) const = &Mesh::color;
-	const typename Mesh::Color&  (Mesh::*color_eh )(EdgeHandle    ) const = &Mesh::color;
-	const typename Mesh::Color&  (Mesh::*color_fh )(FaceHandle    ) const = &Mesh::color;
-
-	// Get value of a standard property (texture coordinate)
-	const typename Mesh::TexCoord1D& (Mesh::*texcoord1D_vh)(VertexHandle  ) const = &Mesh::texcoord1D;
-	const typename Mesh::TexCoord1D& (Mesh::*texcoord1D_hh)(HalfedgeHandle) const = &Mesh::texcoord1D;
-	const typename Mesh::TexCoord2D& (Mesh::*texcoord2D_vh)(VertexHandle  ) const = &Mesh::texcoord2D;
-	const typename Mesh::TexCoord2D& (Mesh::*texcoord2D_hh)(HalfedgeHandle) const = &Mesh::texcoord2D;
-	const typename Mesh::TexCoord3D& (Mesh::*texcoord3D_vh)(VertexHandle  ) const = &Mesh::texcoord3D;
-	const typename Mesh::TexCoord3D& (Mesh::*texcoord3D_hh)(HalfedgeHandle) const = &Mesh::texcoord3D;
-
-	// Get value of a standard property (status)
-	const StatusInfo& (Mesh::*status_vh)(VertexHandle  ) const = &Mesh::status;
-	const StatusInfo& (Mesh::*status_hh)(HalfedgeHandle) const = &Mesh::status;
-	const StatusInfo& (Mesh::*status_eh)(EdgeHandle    ) const = &Mesh::status;
-	const StatusInfo& (Mesh::*status_fh)(FaceHandle    ) const = &Mesh::status;
-
-	// Set value of a standard property (point, normal, color)
-	void (Mesh::*set_normal_vh)(VertexHandle,   const typename Mesh::Normal&) = &Mesh::set_normal;
-	void (Mesh::*set_normal_hh)(HalfedgeHandle, const typename Mesh::Normal&) = &Mesh::set_normal;
-	void (Mesh::*set_normal_fh)(FaceHandle,     const typename Mesh::Normal&) = &Mesh::set_normal;
-	void (Mesh::*set_color_vh )(VertexHandle,   const typename Mesh::Color& ) = &Mesh::set_color;
-	void (Mesh::*set_color_hh )(HalfedgeHandle, const typename Mesh::Color& ) = &Mesh::set_color;
-	void (Mesh::*set_color_eh )(EdgeHandle,     const typename Mesh::Color& ) = &Mesh::set_color;
-	void (Mesh::*set_color_fh )(FaceHandle,     const typename Mesh::Color& ) = &Mesh::set_color;
-
-	// Set value of a standard property (texture coordinate)
-	void (Mesh::*set_texcoord1D_vh)(VertexHandle,   const typename Mesh::TexCoord1D&) = &Mesh::set_texcoord1D;
-	void (Mesh::*set_texcoord1D_hh)(HalfedgeHandle, const typename Mesh::TexCoord1D&) = &Mesh::set_texcoord1D;
-	void (Mesh::*set_texcoord2D_vh)(VertexHandle,   const typename Mesh::TexCoord2D&) = &Mesh::set_texcoord2D;
-	void (Mesh::*set_texcoord2D_hh)(HalfedgeHandle, const typename Mesh::TexCoord2D&) = &Mesh::set_texcoord2D;
-	void (Mesh::*set_texcoord3D_vh)(VertexHandle,   const typename Mesh::TexCoord3D&) = &Mesh::set_texcoord3D;
-	void (Mesh::*set_texcoord3D_hh)(HalfedgeHandle, const typename Mesh::TexCoord3D&) = &Mesh::set_texcoord3D;
-
-	// Set value of a standard property (status)
-	void (*set_status_vh)(Mesh&, VertexHandle,   const StatusInfo&) = &set_status;
-	void (*set_status_hh)(Mesh&, HalfedgeHandle, const StatusInfo&) = &set_status;
-	void (*set_status_eh)(Mesh&, EdgeHandle,     const StatusInfo&) = &set_status;
-	void (*set_status_fh)(Mesh&, FaceHandle,     const StatusInfo&) = &set_status;
-
-	// Property management - add property
-	void (Mesh::*add_property_vph)(VPropHandleT<object>&, const std::string&) = &Mesh::add_property;
-	void (Mesh::*add_property_eph)(EPropHandleT<object>&, const std::string&) = &Mesh::add_property;
-	void (Mesh::*add_property_hph)(HPropHandleT<object>&, const std::string&) = &Mesh::add_property;
-	void (Mesh::*add_property_fph)(FPropHandleT<object>&, const std::string&) = &Mesh::add_property;
-	void (Mesh::*add_property_mph)(MPropHandleT<object>&, const std::string&) = &Mesh::add_property;
-
-	// Property management - remove property
-	void (Mesh::*remove_property_vph)(VPropHandleT<object>&) = &Mesh::remove_property;
-	void (Mesh::*remove_property_eph)(EPropHandleT<object>&) = &Mesh::remove_property;
-	void (Mesh::*remove_property_hph)(HPropHandleT<object>&) = &Mesh::remove_property;
-	void (Mesh::*remove_property_fph)(FPropHandleT<object>&) = &Mesh::remove_property;
-	void (Mesh::*remove_property_mph)(MPropHandleT<object>&) = &Mesh::remove_property;
-
-	// Property management - get property by name
-	bool (Mesh::*get_property_handle_vph)(VPropHandleT<object>&, const std::string&) const = &Mesh::get_property_handle;
-	bool (Mesh::*get_property_handle_eph)(EPropHandleT<object>&, const std::string&) const = &Mesh::get_property_handle;
-	bool (Mesh::*get_property_handle_hph)(HPropHandleT<object>&, const std::string&) const = &Mesh::get_property_handle;
-	bool (Mesh::*get_property_handle_fph)(FPropHandleT<object>&, const std::string&) const = &Mesh::get_property_handle;
-	bool (Mesh::*get_property_handle_mph)(MPropHandleT<object>&, const std::string&) const = &Mesh::get_property_handle;
-
-	// Property management - get property value for an item
-	const object& (Mesh::*property_vertex  )(VPropHandleT<object>, VertexHandle  ) const = &Mesh::property;
-	const object& (Mesh::*property_edge    )(EPropHandleT<object>, EdgeHandle    ) const = &Mesh::property;
-	const object& (Mesh::*property_halfedge)(HPropHandleT<object>, HalfedgeHandle) const = &Mesh::property;
-	const object& (Mesh::*property_face    )(FPropHandleT<object>, FaceHandle    ) const = &Mesh::property;
-	const object& (Mesh::*property_mesh    )(MPropHandleT<object>                ) const = &Mesh::property;
-
-	// Property management - set property value for an item
-	void (*set_property_vertex  )(Mesh&, VPropHandleT<object>, VertexHandle,   const object&) = &set_property;
-	void (*set_property_edge    )(Mesh&, EPropHandleT<object>, EdgeHandle,     const object&) = &set_property;
-	void (*set_property_halfedge)(Mesh&, HPropHandleT<object>, HalfedgeHandle, const object&) = &set_property;
-	void (*set_property_face    )(Mesh&, FPropHandleT<object>, FaceHandle,     const object&) = &set_property;
-	void (*set_property_mesh    )(Mesh&, MPropHandleT<object>,                 const object&) = &set_property;
-
-	// Low-level adding new items
-	VertexHandle (Mesh::*new_vertex_void )(void                        ) = &Mesh::new_vertex;
-	VertexHandle (Mesh::*new_vertex_point)(const typename Mesh::Point& ) = &Mesh::new_vertex;
-	FaceHandle   (Mesh::*new_face_void   )(void                        ) = &Mesh::new_face;
-	FaceHandle   (Mesh::*new_face_face   )(const typename Mesh::Face&  ) = &Mesh::new_face;
-
-	// Kernel item iterators
-	IteratorWrapperT<typename Mesh::VertexIter,   &Mesh::n_vertices > (*vertices )(Mesh&) = &get_iterator;
-	IteratorWrapperT<typename Mesh::HalfedgeIter, &Mesh::n_halfedges> (*halfedges)(Mesh&) = &get_iterator;
-	IteratorWrapperT<typename Mesh::EdgeIter,     &Mesh::n_edges    > (*edges    )(Mesh&) = &get_iterator;
-	IteratorWrapperT<typename Mesh::FaceIter,     &Mesh::n_faces    > (*faces    )(Mesh&) = &get_iterator;
-
-	IteratorWrapperT<typename Mesh::VertexIter,   &Mesh::n_vertices > (*svertices )(Mesh&) = &get_skipping_iterator;
-	IteratorWrapperT<typename Mesh::HalfedgeIter, &Mesh::n_halfedges> (*shalfedges)(Mesh&) = &get_skipping_iterator;
-	IteratorWrapperT<typename Mesh::EdgeIter,     &Mesh::n_edges    > (*sedges    )(Mesh&) = &get_skipping_iterator;
-	IteratorWrapperT<typename Mesh::FaceIter,     &Mesh::n_faces    > (*sfaces    )(Mesh&) = &get_skipping_iterator;
-
-	//======================================================================
-	//  BaseKernel Function Pointers
-	//======================================================================
-
-	// Copy property
-	void (Mesh::*copy_property_vprop)(VPropHandleT<object>&, VertexHandle,   VertexHandle  ) = &Mesh::copy_property;
-	void (Mesh::*copy_property_hprop)(HPropHandleT<object>,  HalfedgeHandle, HalfedgeHandle) = &Mesh::copy_property;
-	void (Mesh::*copy_property_eprop)(EPropHandleT<object>,  EdgeHandle,     EdgeHandle    ) = &Mesh::copy_property;
-	void (Mesh::*copy_property_fprop)(FPropHandleT<object>,  FaceHandle,     FaceHandle    ) = &Mesh::copy_property;
-
-	// Copy all properties
-	void (Mesh::*copy_all_properties_vh_vh_bool)(VertexHandle,   VertexHandle,   bool) = &Mesh::copy_all_properties;
-	void (Mesh::*copy_all_properties_hh_hh_bool)(HalfedgeHandle, HalfedgeHandle, bool) = &Mesh::copy_all_properties;
-	void (Mesh::*copy_all_properties_eh_eh_bool)(EdgeHandle,     EdgeHandle,     bool) = &Mesh::copy_all_properties;
-	void (Mesh::*copy_all_properties_fh_fh_bool)(FaceHandle,     FaceHandle,     bool) = &Mesh::copy_all_properties;
-
-	//======================================================================
-	//  PolyConnectivity Function Pointers
-	//======================================================================
-
-	// Assign connectivity
-	void (*assign_connectivity_poly)(Mesh&, const PolyMesh&) = &assign_connectivity;
-	void (*assign_connectivity_tri )(Mesh&, const TriMesh& ) = &assign_connectivity;
-
-	// Vertex and face valence
-	unsigned int (Mesh::*valence_vh)(VertexHandle) const = &Mesh::valence;
-	unsigned int (Mesh::*valence_fh)(FaceHandle  ) const = &Mesh::valence;
-
-	// Triangulate face or mesh
-	void (Mesh::*triangulate_fh  )(FaceHandle) = &Mesh::triangulate;
-	void (Mesh::*triangulate_void)(          ) = &Mesh::triangulate;
-
-	// Deleting mesh items and other connectivity/topology modifications
-	void (Mesh::*delete_vertex)(VertexHandle, bool) = &Mesh::delete_vertex;
-	void (Mesh::*delete_edge  )(EdgeHandle,   bool) = &Mesh::delete_edge;
-	void (Mesh::*delete_face  )(FaceHandle,   bool) = &Mesh::delete_face;
-
-	// Vertex and Face circulators
-	CirculatorWrapperT<typename Mesh::VertexVertexIter,    VertexHandle  > (*vv )(Mesh&, VertexHandle  ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::VertexIHalfedgeIter, VertexHandle  > (*vih)(Mesh&, VertexHandle  ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::VertexOHalfedgeIter, VertexHandle  > (*voh)(Mesh&, VertexHandle  ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::VertexEdgeIter,      VertexHandle  > (*ve )(Mesh&, VertexHandle  ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::VertexFaceIter,      VertexHandle  > (*vf )(Mesh&, VertexHandle  ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::FaceVertexIter,      FaceHandle    > (*fv )(Mesh&, FaceHandle    ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::FaceHalfedgeIter,    FaceHandle    > (*fh )(Mesh&, FaceHandle    ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::FaceEdgeIter,        FaceHandle    > (*fe )(Mesh&, FaceHandle    ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::FaceFaceIter,        FaceHandle    > (*ff )(Mesh&, FaceHandle    ) = &get_circulator;
-	CirculatorWrapperT<typename Mesh::HalfedgeLoopIter,    HalfedgeHandle> (*hl )(Mesh&, HalfedgeHandle) = &get_circulator;
-
-	// Boundary and manifold tests
-	bool (Mesh::*is_boundary_hh)(HalfedgeHandle  ) const = &Mesh::is_boundary;
-	bool (Mesh::*is_boundary_eh)(EdgeHandle      ) const = &Mesh::is_boundary;
-	bool (Mesh::*is_boundary_vh)(VertexHandle    ) const = &Mesh::is_boundary;
-	bool (Mesh::*is_boundary_fh)(FaceHandle, bool) const = &Mesh::is_boundary;
-
-	// Generic handle derefertiation
-	const typename Mesh::Vertex&   (Mesh::*deref_vh)(VertexHandle  ) const = &Mesh::deref;
-	const typename Mesh::Halfedge& (Mesh::*deref_hh)(HalfedgeHandle) const = &Mesh::deref;
-	const typename Mesh::Edge&     (Mesh::*deref_eh)(EdgeHandle    ) const = &Mesh::deref;
-	const typename Mesh::Face&     (Mesh::*deref_fh)(FaceHandle    ) const = &Mesh::deref;
-
-	//======================================================================
-	//  PolyMeshT Function Pointers
-	//======================================================================
-
-	void (Mesh::*calc_edge_vector_eh_normal)(EdgeHandle,     Normal&) const = &Mesh::calc_edge_vector;
-	void (Mesh::*calc_edge_vector_hh_normal)(HalfedgeHandle, Normal&) const = &Mesh::calc_edge_vector;
-
-	Normal (Mesh::*calc_edge_vector_eh)(EdgeHandle    ) const = &Mesh::calc_edge_vector;
-	Normal (Mesh::*calc_edge_vector_hh)(HalfedgeHandle) const = &Mesh::calc_edge_vector;
-
-	Scalar (Mesh::*calc_edge_length_eh)(EdgeHandle    ) const = &Mesh::calc_edge_length;
-	Scalar (Mesh::*calc_edge_length_hh)(HalfedgeHandle) const = &Mesh::calc_edge_length;
-
-	Scalar (Mesh::*calc_edge_sqr_length_eh)(EdgeHandle    ) const = &Mesh::calc_edge_sqr_length;
-	Scalar (Mesh::*calc_edge_sqr_length_hh)(HalfedgeHandle) const = &Mesh::calc_edge_sqr_length;
-
-	Scalar (Mesh::*calc_dihedral_angle_fast_hh)(HalfedgeHandle) const = &Mesh::calc_dihedral_angle_fast;
-	Scalar (Mesh::*calc_dihedral_angle_fast_eh)(EdgeHandle    ) const = &Mesh::calc_dihedral_angle_fast;
-
-	Scalar (Mesh::*calc_dihedral_angle_hh)(HalfedgeHandle) const = &Mesh::calc_dihedral_angle;
-	Scalar (Mesh::*calc_dihedral_angle_eh)(EdgeHandle    ) const = &Mesh::calc_dihedral_angle;
-
-	unsigned int (Mesh::*find_feature_edges)(Scalar) = &Mesh::find_feature_edges;
-
-	void (Mesh::*split_fh_vh)(FaceHandle, VertexHandle) = &Mesh::split;
-	void (Mesh::*split_eh_vh)(EdgeHandle, VertexHandle) = &Mesh::split;
-
-	void (Mesh::*update_normal_fh)(FaceHandle            ) = &Mesh::update_normal;
-	void (Mesh::*update_normal_hh)(HalfedgeHandle, double) = &Mesh::update_normal;
-	void (Mesh::*update_normal_vh)(VertexHandle          ) = &Mesh::update_normal;
-
-	void (Mesh::*update_halfedge_normals)(double) = &Mesh::update_halfedge_normals;
-
-	Normal (Mesh::*calc_face_normal    )(FaceHandle            ) const = &Mesh::calc_face_normal;
-	Normal (Mesh::*calc_halfedge_normal)(HalfedgeHandle, double) const = &Mesh::calc_halfedge_normal;
-
-	void  (Mesh::*calc_face_centroid_fh_point)(FaceHandle, Point&) const = &Mesh::calc_face_centroid;
-	Point (Mesh::*calc_face_centroid_fh      )(FaceHandle        ) const = &Mesh::calc_face_centroid;
-
-	//======================================================================
-	//  Mesh Type
-	//======================================================================
-
-	class_<Mesh> class_mesh(_name);
-
-	class_mesh
-
-		//======================================================================
-		//  KernelT
-		//======================================================================
-
-		.def("reserve", &Mesh::reserve)
-
-		.def("vertex", vertex, return_value_policy<reference_existing_object>())
-		.def("halfedge", halfedge, return_value_policy<reference_existing_object>())
-		.def("edge", edge, return_value_policy<reference_existing_object>())
-		.def("face", face, return_value_policy<reference_existing_object>())
-
-		.def("handle", handle_v)
-		.def("handle", handle_h)
-		.def("handle", handle_e)
-		.def("handle", handle_f)
-
-		.def("vertex_handle", vertex_handle_uint)
-		.def("halfedge_handle", halfedge_handle_uint)
-		.def("edge_handle", edge_handle_uint)
-		.def("face_handle", face_handle_uint)
-
-		.def("clear", &Mesh::clear)
-		.def("clean", &Mesh::clean)
-		.def("garbage_collection", garbage_collection_bools, garbage_collection_overloads())
-		.def("garbage_collection", garbage_collection_lists_bools)
-
-		.def("n_vertices", &Mesh::n_vertices)
-		.def("n_halfedges", &Mesh::n_halfedges)
-		.def("n_edges", &Mesh::n_edges)
-		.def("n_faces", &Mesh::n_faces)
-		.def("vertices_empty", &Mesh::vertices_empty)
-		.def("halfedges_empty", &Mesh::halfedges_empty)
-		.def("edges_empty", &Mesh::edges_empty)
-		.def("faces_empty", &Mesh::faces_empty)
-
-		.def("halfedge_handle", halfedge_handle_vh)
-		.def("set_halfedge_handle", set_halfedge_handle_vh_hh)
-
-		.def("to_vertex_handle", &Mesh::to_vertex_handle)
-		.def("from_vertex_handle", &Mesh::from_vertex_handle)
-		.def("set_vertex_handle", &Mesh::set_vertex_handle)
-		.def("face_handle", face_handle_hh)
-		.def("set_face_handle", &Mesh::set_face_handle)
-		.def("next_halfedge_handle", &Mesh::next_halfedge_handle)
-		.def("set_next_halfedge_handle", &Mesh::set_next_halfedge_handle)
-		.def("prev_halfedge_handle", prev_halfedge_handle_hh)
-		.def("opposite_halfedge_handle", &Mesh::opposite_halfedge_handle)
-		.def("ccw_rotated_halfedge_handle", &Mesh::ccw_rotated_halfedge_handle)
-		.def("cw_rotated_halfedge_handle", &Mesh::cw_rotated_halfedge_handle)
-		.def("edge_handle", edge_handle_hh)
-
-		.def("halfedge_handle", halfedge_handle_eh_uint)
-
-		.def("halfedge_handle", halfedge_handle_fh)
-		.def("set_halfedge_handle", set_halfedge_handle_fh_hh)
-
-		.def("point", point_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_point", &Mesh::set_point)
-		.def("normal", normal_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_normal", set_normal_vh)
-		.def("normal", normal_hh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_normal", set_normal_hh)
-		.def("color", color_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_color", set_color_vh)
-		.def("texcoord1D", texcoord1D_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_texcoord1D", set_texcoord1D_vh)
-		.def("texcoord2D", texcoord2D_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_texcoord2D", set_texcoord2D_vh)
-		.def("texcoord3D", texcoord3D_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_texcoord3D", set_texcoord3D_vh)
-		.def("texcoord1D", texcoord1D_hh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_texcoord1D", set_texcoord1D_hh)
-		.def("texcoord2D", texcoord2D_hh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_texcoord2D", set_texcoord2D_hh)
-		.def("texcoord3D", texcoord3D_hh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_texcoord3D", set_texcoord3D_hh)
-		.def("status", status_vh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_status", set_status_vh)
-		.def("status", status_hh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_status", set_status_hh)
-		.def("color", color_hh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_color", set_color_hh)
-		.def("color", color_eh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_color", set_color_eh)
-		.def("status", status_eh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_status", set_status_eh)
-		.def("normal", normal_fh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_normal", set_normal_fh)
-		.def("color", color_fh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_color", set_color_fh)
-		.def("status", status_fh, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("set_status", set_status_fh)
-
-		.def("request_vertex_normals", &Mesh::request_vertex_normals)
-		.def("request_vertex_colors", &Mesh::request_vertex_colors)
-		.def("request_vertex_texcoords1D", &Mesh::request_vertex_texcoords1D)
-		.def("request_vertex_texcoords2D", &Mesh::request_vertex_texcoords2D)
-		.def("request_vertex_texcoords3D", &Mesh::request_vertex_texcoords3D)
-		.def("request_vertex_status", &Mesh::request_vertex_status)
-		.def("request_halfedge_status", &Mesh::request_halfedge_status)
-		.def("request_halfedge_normals", &Mesh::request_halfedge_normals)
-		.def("request_halfedge_colors", &Mesh::request_halfedge_colors)
-		.def("request_halfedge_texcoords1D", &Mesh::request_halfedge_texcoords1D)
-		.def("request_halfedge_texcoords2D", &Mesh::request_halfedge_texcoords2D)
-		.def("request_halfedge_texcoords3D", &Mesh::request_halfedge_texcoords3D)
-		.def("request_edge_status", &Mesh::request_edge_status)
-		.def("request_edge_colors", &Mesh::request_edge_colors)
-		.def("request_face_normals", &Mesh::request_face_normals)
-		.def("request_face_colors", &Mesh::request_face_colors)
-		.def("request_face_status", &Mesh::request_face_status)
-		.def("request_face_texture_index", &Mesh::request_face_texture_index)
-
-		.def("release_vertex_normals", &Mesh::release_vertex_normals)
-		.def("release_vertex_colors", &Mesh::release_vertex_colors)
-		.def("release_vertex_texcoords1D", &Mesh::release_vertex_texcoords1D)
-		.def("release_vertex_texcoords2D", &Mesh::release_vertex_texcoords2D)
-		.def("release_vertex_texcoords3D", &Mesh::release_vertex_texcoords3D)
-		.def("release_vertex_status", &Mesh::release_vertex_status)
-		.def("release_halfedge_status", &Mesh::release_halfedge_status)
-		.def("release_halfedge_normals", &Mesh::release_halfedge_normals)
-		.def("release_halfedge_colors", &Mesh::release_halfedge_colors)
-		.def("release_halfedge_texcoords1D", &Mesh::release_halfedge_texcoords1D)
-		.def("release_halfedge_texcoords2D", &Mesh::release_halfedge_texcoords2D)
-		.def("release_halfedge_texcoords3D", &Mesh::release_halfedge_texcoords3D)
-		.def("release_edge_status", &Mesh::release_edge_status)
-		.def("release_edge_colors", &Mesh::release_edge_colors)
-		.def("release_face_normals", &Mesh::release_face_normals)
-		.def("release_face_colors", &Mesh::release_face_colors)
-		.def("release_face_status", &Mesh::release_face_status)
-		.def("release_face_texture_index", &Mesh::release_face_texture_index)
-
-		.def("has_vertex_normals", &Mesh::has_vertex_normals)
-		.def("has_vertex_colors", &Mesh::has_vertex_colors)
-		.def("has_vertex_texcoords1D", &Mesh::has_vertex_texcoords1D)
-		.def("has_vertex_texcoords2D", &Mesh::has_vertex_texcoords2D)
-		.def("has_vertex_texcoords3D", &Mesh::has_vertex_texcoords3D)
-		.def("has_vertex_status", &Mesh::has_vertex_status)
-		.def("has_halfedge_status", &Mesh::has_halfedge_status)
-		.def("has_halfedge_normals", &Mesh::has_halfedge_normals)
-		.def("has_halfedge_colors", &Mesh::has_halfedge_colors)
-		.def("has_halfedge_texcoords1D", &Mesh::has_halfedge_texcoords1D)
-		.def("has_halfedge_texcoords2D", &Mesh::has_halfedge_texcoords2D)
-		.def("has_halfedge_texcoords3D", &Mesh::has_halfedge_texcoords3D)
-		.def("has_edge_status", &Mesh::has_edge_status)
-		.def("has_edge_colors", &Mesh::has_edge_colors)
-		.def("has_face_normals", &Mesh::has_face_normals)
-		.def("has_face_colors", &Mesh::has_face_colors)
-		.def("has_face_status", &Mesh::has_face_status)
-		.def("has_face_texture_index", &Mesh::has_face_texture_index)
-
-		.def("add_property", add_property_vph, add_property_overloads())
-		.def("add_property", add_property_eph, add_property_overloads())
-		.def("add_property", add_property_hph, add_property_overloads())
-		.def("add_property", add_property_fph, add_property_overloads())
-		.def("add_property", add_property_mph, add_property_overloads())
-
-		.def("remove_property", remove_property_vph)
-		.def("remove_property", remove_property_eph)
-		.def("remove_property", remove_property_hph)
-		.def("remove_property", remove_property_fph)
-		.def("remove_property", remove_property_mph)
-
-		.def("get_property_handle", get_property_handle_vph)
-		.def("get_property_handle", get_property_handle_eph)
-		.def("get_property_handle", get_property_handle_hph)
-		.def("get_property_handle", get_property_handle_fph)
-		.def("get_property_handle", get_property_handle_mph)
-
-		.def("property", property_vertex, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("property", property_edge, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("property", property_halfedge, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("property", property_face, OPENMESH_PYTHON_DEFAULT_POLICY)
-		.def("property", property_mesh, OPENMESH_PYTHON_DEFAULT_POLICY)
-
-		.def("set_property", set_property_vertex)
-		.def("set_property", set_property_edge)
-		.def("set_property", set_property_halfedge)
-		.def("set_property", set_property_face)
-		.def("set_property", set_property_mesh)
-
-		.def("new_vertex", new_vertex_void)
-		.def("new_vertex", new_vertex_point)
-		.def("new_edge", &Mesh::new_edge)
-		.def("new_face", new_face_void)
-		.def("new_face", new_face_face)
-
-		.def("vertices", vertices)
-		.def("halfedges", halfedges)
-		.def("edges", edges)
-		.def("faces", faces)
-
-		.def("svertices", svertices)
-		.def("shalfedges", shalfedges)
-		.def("sedges", sedges)
-		.def("sfaces", sfaces)
-
-		//======================================================================
-		//  BaseKernel
-		//======================================================================
-
-		.def("copy_property", copy_property_vprop)
-		.def("copy_property", copy_property_hprop)
-		.def("copy_property", copy_property_eprop)
-		.def("copy_property", copy_property_fprop)
-
-		.def("copy_all_properties", copy_all_properties_vh_vh_bool, copy_all_properties_overloads())
-		.def("copy_all_properties", copy_all_properties_hh_hh_bool, copy_all_properties_overloads())
-		.def("copy_all_properties", copy_all_properties_eh_eh_bool, copy_all_properties_overloads())
-		.def("copy_all_properties", copy_all_properties_fh_fh_bool, copy_all_properties_overloads())
-
-		//======================================================================
-		//  PolyConnectivity
-		//======================================================================
-
-		.def("assign_connectivity", assign_connectivity_poly)
-		.def("assign_connectivity", assign_connectivity_tri)
-
-		.def("opposite_face_handle", &Mesh::opposite_face_handle)
-		.def("adjust_outgoing_halfedge", &Mesh::adjust_outgoing_halfedge)
-		.def("find_halfedge", &Mesh::find_halfedge)
-		.def("valence", valence_vh)
-		.def("valence", valence_fh)
-		.def("collapse", &Mesh::collapse)
-		.def("is_simple_link", &Mesh::is_simple_link)
-		.def("is_simply_connected", &Mesh::is_simply_connected)
-		.def("remove_edge", &Mesh::remove_edge)
-		.def("reinsert_edge", &Mesh::reinsert_edge)
-		.def("triangulate", triangulate_fh)
-		.def("triangulate", triangulate_void)
-		.def("split_edge", &Mesh::split_edge)
-		.def("split_edge_copy", &Mesh::split_edge_copy)
-
-		.def("add_vertex", &Mesh::add_vertex)
-
-		.def("is_collapse_ok",  &Mesh::is_collapse_ok)
-		.def("delete_vertex", delete_vertex, delete_vertex_overloads())
-		.def("delete_edge", delete_edge, delete_edge_overloads())
-		.def("delete_face", delete_face, delete_face_overloads())
-
-		.def("vv", vv)
-		.def("vih", vih)
-		.def("voh", voh)
-		.def("ve", ve)
-		.def("vf", vf)
-
-		.def("fv", fv)
-		.def("fh", fh)
-		.def("fe", fe)
-		.def("ff", ff)
-
-		.def("hl", hl)
-
-		.def("is_boundary", is_boundary_hh)
-		.def("is_boundary", is_boundary_eh)
-		.def("is_boundary", is_boundary_vh)
-		.def("is_boundary", is_boundary_fh, is_boundary_overloads())
-		.def("is_manifold", &Mesh::is_manifold)
-
-		.def("deref", deref_vh, return_value_policy<reference_existing_object>())
-		.def("deref", deref_hh, return_value_policy<reference_existing_object>())
-		.def("deref", deref_eh, return_value_policy<reference_existing_object>())
-		.def("deref", deref_fh, return_value_policy<reference_existing_object>())
-
-		.def("is_triangles", &Mesh::is_triangles)
-		.staticmethod("is_triangles")
-
-		.def_readonly("InvalidVertexHandle", &Mesh::InvalidVertexHandle)
-		.def_readonly("InvalidHalfedgeHandle", &Mesh::InvalidHalfedgeHandle)
-		.def_readonly("InvalidEdgeHandle", &Mesh::InvalidEdgeHandle)
-		.def_readonly("InvalidFaceHandle", &Mesh::InvalidFaceHandle)
-
-		//======================================================================
-		//  PolyMeshT
-		//======================================================================
-
-		.def("add_vertex", &Mesh::add_vertex)
-
-		.def("calc_edge_vector", calc_edge_vector_eh_normal)
-		.def("calc_edge_vector", calc_edge_vector_eh)
-		.def("calc_edge_vector", calc_edge_vector_hh_normal)
-		.def("calc_edge_vector", calc_edge_vector_hh)
-
-		.def("calc_edge_length", calc_edge_length_eh)
-		.def("calc_edge_length", calc_edge_length_hh)
-		.def("calc_edge_sqr_length", calc_edge_sqr_length_eh)
-		.def("calc_edge_sqr_length", calc_edge_sqr_length_hh)
-
-		.def("calc_sector_vectors", &Mesh::calc_sector_vectors)
-		.def("calc_sector_angle", &Mesh::calc_sector_angle)
-		.def("calc_sector_normal", &Mesh::calc_sector_normal)
-		.def("calc_sector_area", &Mesh::calc_sector_area)
-
-		.def("calc_dihedral_angle_fast", calc_dihedral_angle_fast_hh)
-		.def("calc_dihedral_angle_fast", calc_dihedral_angle_fast_eh)
-		.def("calc_dihedral_angle", calc_dihedral_angle_hh)
-		.def("calc_dihedral_angle", calc_dihedral_angle_eh)
-
-		.def("find_feature_edges", find_feature_edges, find_feature_edges_overloads())
-
-		.def("split", split_fh_vh)
-		.def("split", split_eh_vh)
-
-		.def("update_normals", &Mesh::update_normals)
-		.def("update_normal", update_normal_fh)
-		.def("update_face_normals", &Mesh::update_face_normals)
-
-		.def("calc_face_normal", calc_face_normal)
-
-		.def("calc_face_centroid", calc_face_centroid_fh_point)
-		.def("calc_face_centroid", calc_face_centroid_fh)
-
-		.def("update_normal", update_normal_hh, update_normal_overloads())
-		.def("update_halfedge_normals", update_halfedge_normals, update_halfedge_normals_overloads())
-
-		.def("calc_halfedge_normal", calc_halfedge_normal, calc_halfedge_normal_overloads())
-
-		.def("is_estimated_feature_edge", &Mesh::is_estimated_feature_edge)
-
-		.def("update_normal", update_normal_vh)
-		.def("update_vertex_normals", &Mesh::update_vertex_normals)
-
-		.def("calc_vertex_normal", &Mesh::calc_vertex_normal)
-		.def("calc_vertex_normal_fast", &Mesh::calc_vertex_normal_fast)
-		.def("calc_vertex_normal_correct", &Mesh::calc_vertex_normal_correct)
-		.def("calc_vertex_normal_loop", &Mesh::calc_vertex_normal_loop)
-
-		.def("is_polymesh", &Mesh::is_polymesh)
-		.staticmethod("is_polymesh")
-
-		.def("is_trimesh", &Mesh::is_trimesh)
-		.staticmethod("is_trimesh")
-		;
-
-	expose_type_specific_functions(class_mesh);
-
-	//======================================================================
-	//  Nested Types
-	//======================================================================
-
-	// Enter mesh scope
-	scope scope_mesh = class_mesh;
-
-	// Point
-	const boost::python::type_info point_info = type_id<typename Mesh::Point>();
-	const converter::registration * point_registration = converter::registry::query(point_info);
-	scope_mesh.attr("Point") = handle<>(point_registration->m_class_object);
-
-	// Normal
-	const boost::python::type_info normal_info = type_id<typename Mesh::Normal>();
-	const converter::registration * normal_registration = converter::registry::query(normal_info);
-	scope_mesh.attr("Normal") = handle<>(normal_registration->m_class_object);
-
-	// Color
-	const boost::python::type_info color_info = type_id<typename Mesh::Color>();
-	const converter::registration * color_registration = converter::registry::query(color_info);
-	scope_mesh.attr("Color") = handle<>(color_registration->m_class_object);
-
-	// TexCoord2D
-	const boost::python::type_info texcoord2d_info = type_id<typename Mesh::TexCoord2D>();
-	const converter::registration * texcoord2d_registration = converter::registry::query(texcoord2d_info);
-	scope_mesh.attr("TexCoord2D") = handle<>(texcoord2d_registration->m_class_object);
-
-	// TexCoord3D
-	const boost::python::type_info texcoord3d_info = type_id<typename Mesh::TexCoord3D>();
-	const converter::registration * texcoord3d_registration = converter::registry::query(texcoord3d_info);
-	scope_mesh.attr("TexCoord3D") = handle<>(texcoord3d_registration->m_class_object);
-}
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/PropertyManager.hh

@@ -1,143 +0,0 @@
-#ifndef OPENMESH_PYTHON_PROPERTYMANAGER_HH
-#define OPENMESH_PYTHON_PROPERTYMANAGER_HH
-
-#include "Python/Bindings.hh"
-#include "OpenMesh/Core/Utils/PropertyManager.hh"
-
-namespace OpenMesh {
-namespace Python {
-
-BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(retain_overloads, retain, 0, 1)
-
-/**
- * Implementation of %Python's \_\_getitem\_\_ magic method.
- *
- * @tparam PropertyManager A property manager type.
- * @tparam IndexHandle The appropriate handle type.
- *
- * @param _self The property manager instance that is to be used.
- * @param _handle The index of the property value to be returned.
- *
- * @return The requested property value.
- */
-template <class PropertyManager, class IndexHandle>
-object propman_get_item(PropertyManager& _self, IndexHandle _handle) {
-	return _self[_handle];
-}
-
-/**
- * Implementation of %Python's \_\_setitem\_\_ magic method.
- *
- * @tparam PropertyManager A property manager type.
- * @tparam IndexHandle The appropriate handle type.
- *
- * @param _self The property manager instance that is to be used.
- * @param _handle The index of the property value to be set.
- * @param _value The property value to be set.
- */
-template <class PropertyManager, class IndexHandle>
-void propman_set_item(PropertyManager& _self, IndexHandle _handle, object _value) {
-	_self[_handle] = _value;
-}
-
-/**
- * Conveniently set the property value for an entire range of mesh items
- * using a %Python iterator.
- *
- * @tparam PropertyManager A property manager type.
- * @tparam Iterator A %Python iterator type.
- *
- * @param _self The property manager instance that is to be used.
- * @param _it An iterator that iterates over the items in the range.
- * @param _value The value the range will be set to.
- */
-template <class PropertyManager, class Iterator>
-void propman_set_range(PropertyManager& _self, Iterator _it, object _value) {
-	try {
-		while (true) {
-			_self[_it.next()] = _value;
-		}
-	}
-	catch (error_already_set exception) {
-		// This is expected behavior
-		PyErr_Clear();
-	}
-}
-
-/**
- * Thin wrapper for propertyExists.
- *
- * @tparam PropertyManager A property manager type.
- * @tparam Mesh A mesh type.
- *
- * @param _mesh The mesh that is used to check if the property exists.
- * @param _propname The name of the property.
- */
-template <class PropertyManager, class Mesh>
-bool property_exists(Mesh& _mesh, const char *_propname) {
-	return PropertyManager::propertyExists(_mesh, _propname);
-}
-
-/**
- * Expose a property manager type to %Python.
- *
- * This function template is used to expose property managers to %Python. The
- * template parameters are used to instantiate the appropriate property manager
- * type.
- *
- * @tparam PropHandle A property handle type (e.g. %VPropHandle\<object\>).
- * @tparam IndexHandle The appropriate handle type (e.g. %VertexHandle for
- * %VPropHandle\<object\>).
- * @tparam Iterator A %Python iterator type. This type is used to instantiate
- * the propman_set_range function.
- *
- * @param _name The name of the property manager type to be exposed.
- */
-template <class PropHandle, class IndexHandle, class Iterator>
-void expose_property_manager(const char *_name) {
-	// Convenience typedef
-	typedef PropertyManager<PropHandle, PolyConnectivity> PropertyManager;
-
-	// Function pointers
-	void (PropertyManager::*retain)(bool) = &PropertyManager::retain;
-
-	object (*getitem)(PropertyManager&, IndexHandle        ) = &propman_get_item;
-	void   (*setitem)(PropertyManager&, IndexHandle, object) = &propman_set_item;
-
-	void (*set_range)(PropertyManager&, Iterator, object) = &propman_set_range;
-
-	bool (*property_exists_poly)(PolyMesh&, const char *) = &property_exists<PropertyManager, PolyMesh>;
-	bool (*property_exists_tri )(TriMesh&,  const char *) = &property_exists<PropertyManager, TriMesh >;
-
-	// Expose property manager
-	class_<PropertyManager, boost::noncopyable>(_name)
-		.def(init<PolyMesh&, const char *, optional<bool> >()[with_custodian_and_ward<1,2>()])
-		.def(init<TriMesh&,  const char *, optional<bool> >()[with_custodian_and_ward<1,2>()])
-
-		.def("swap", &PropertyManager::swap)
-		.def("is_valid", &PropertyManager::isValid)
-
-		.def("__bool__", &PropertyManager::operator bool)
-		.def("__nonzero__", &PropertyManager::operator bool)
-
-		.def("get_raw_property", &PropertyManager::getRawProperty, return_value_policy<copy_const_reference>())
-		.def("get_name", &PropertyManager::getName, return_value_policy<copy_const_reference>())
-		.def("get_mesh", &PropertyManager::getMesh, return_value_policy<reference_existing_object>())
-
-		.def("retain", retain, retain_overloads())
-
-		.def("__getitem__", getitem)
-		.def("__setitem__", setitem)
-
-		.def("set_range", set_range)
-
-		.def("property_exists", property_exists_poly)
-		.def("property_exists", property_exists_tri)
-		.staticmethod("property_exists")
-		;
-}
-
-} // namespace OpenMesh
-} // namespace Python
-
-#endif

src/Python/Unittests/test_add_face.py

@@ -1,334 +0,0 @@
-import unittest
-import openmesh
-
-class AddFace(unittest.TestCase):
-
-    def test_add_triangles_to_trimesh(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-
-        # Add two faces
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #  1 === 2
-        #  |   / |    
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 4)
-        self.assertEqual(self.mesh.n_faces(), 2)
-
-    def test_add_quad_to_trimesh(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-
-        # Add two faces
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #  1 === 2
-        #  |   / |    
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 4)
-        self.assertEqual(self.mesh.n_faces(), 2)
-        
-    def test_create_triangle_mesh_cube(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-    def test_create_strange_config(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        #    2 x-----------x 1
-        #       \         /
-        #        \       /
-        #         \     /
-        #          \   /
-        #           \ /
-        #          0 x ---x 6
-        #           /|\   |
-        #          / | \  |
-        #         /  |  \ |
-        #        /   |   \|
-        #       x----x    x
-        #       3    4    5
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 2, 2)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 3, 3)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 4, 4)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(5, 5, 5)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(6, 6, 6)))
-        
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[5], self.vhandle[6])
-        
-        # non-manifold!
-        invalid_fh = self.mesh.add_face(self.vhandle[3], self.vhandle[0], self.vhandle[4])
-
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 7)
-        self.assertEqual(self.mesh.n_faces(), 3)
-        self.assertEqual(invalid_fh, openmesh.TriMesh.InvalidFaceHandle)
-        
-    def test_add_quad_to_polymesh(self):
-        self.mesh = openmesh.PolyMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-
-        # Add one face
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #  1 === 2
-        #  |     |    
-        #  |     |
-        #  |     |
-        #  0 === 3
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 4)
-        self.assertEqual(self.mesh.n_faces(), 1)
-        
-    def test_create_poly_mesh_cube(self):
-        self.mesh = openmesh.PolyMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 24)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(AddFace)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_boundary.py

@@ -1,86 +0,0 @@
-import unittest
-import openmesh
-
-class BoundaryTriangleMesh(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
-        
-        # Single point
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-2, 0)))
-        
-        # Add five faces
-        self.fhandle = []
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.fhandle.append(self.mesh.add_face(face_vhandles))
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.fhandle.append(self.mesh.add_face(face_vhandles))
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[1])
-        self.fhandle.append(self.mesh.add_face(face_vhandles))
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        self.fhandle.append(self.mesh.add_face(face_vhandles))
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[4])
-        self.fhandle.append(self.mesh.add_face(face_vhandles))
-
-        # Test setup:
-        #  0 ==== 2
-        #  |\  0 /|\
-        #  | \  / | \
-        #  |2  1 3|4 5
-        #  | /  \ | /
-        #  |/  1 \|/
-        #  3 ==== 4
-        #
-        # Vertex 6 single
-
-    def test_boundary_vertex(self):
-        self.assertTrue (self.mesh.is_boundary(self.vhandle[0]))
-        self.assertFalse(self.mesh.is_boundary(self.vhandle[1]))
-        self.assertTrue (self.mesh.is_boundary(self.vhandle[2]))
-        self.assertTrue (self.mesh.is_boundary(self.vhandle[3]))
-        self.assertTrue (self.mesh.is_boundary(self.vhandle[4]))
-        self.assertTrue (self.mesh.is_boundary(self.vhandle[5]))
-        
-        self.assertTrue (self.mesh.is_boundary(self.vhandle[6]))
-        
-    def test_boundary_face(self):
-        self.assertTrue (self.mesh.is_boundary(self.fhandle[0]))
-        self.assertTrue (self.mesh.is_boundary(self.fhandle[1]))
-        self.assertTrue (self.mesh.is_boundary(self.fhandle[2]))
-        self.assertFalse(self.mesh.is_boundary(self.fhandle[3]))
-        self.assertTrue (self.mesh.is_boundary(self.fhandle[4]))
-        
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(BoundaryTriangleMesh)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_delete_face.py

@@ -1,530 +0,0 @@
-import unittest
-import openmesh
-
-class DeleteFaceTriangleMesh(unittest.TestCase):
-
-    def test_delete_half_triangle_mesh_cube_no_edge_status(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # =====================================================
-        # Now we delete half of the mesh
-        # =====================================================
-        self.mesh.request_face_status()
-        self.mesh.request_vertex_status()
-        self.mesh.request_halfedge_status()
-        
-        n_face_to_delete = self.mesh.n_faces() / 2
-        
-        # Check the variable
-        self.assertEqual(n_face_to_delete, 6)
-        
-        for i in range(int(n_face_to_delete)):
-            self.mesh.delete_face(self.mesh.face_handle(i))
-            
-        # =====================================================
-        # Check config afterwards
-        # =====================================================
-        
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # =====================================================
-        # Cleanup and recheck
-        # =====================================================
-        
-        self.mesh.garbage_collection()
-        
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-        
-    def test_delete_half_triangle_mesh_cube_with_edge_status(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        #=======================
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # =====================================================
-        # Now we delete half of the mesh
-        # =====================================================
-        self.mesh.request_face_status()
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_halfedge_status()
-        
-        n_face_to_delete = self.mesh.n_faces() / 2
-        
-        # Check the variable
-        self.assertEqual(n_face_to_delete, 6)
-        
-        for i in range(int(n_face_to_delete)):
-            self.mesh.delete_face(self.mesh.face_handle(i))
-            
-        # =====================================================
-        # Check config afterwards
-        # =====================================================
-        
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # =====================================================
-        # Cleanup and recheck
-        # =====================================================
-        
-        self.mesh.garbage_collection()
-        
-        self.assertEqual(self.mesh.n_edges(), 13)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-        
-    def test_deletete_half_poly_mesh_cube_without_edge_status(self):
-        self.mesh = openmesh.PolyMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 24)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-        
-        # =====================================================
-        # Now we delete half of the mesh
-        # =====================================================
-        self.mesh.request_face_status()
-        self.mesh.request_vertex_status()
-        self.mesh.request_halfedge_status()
-        
-        n_face_to_delete = self.mesh.n_faces() / 2
-        
-        # Check the variable
-        self.assertEqual(n_face_to_delete, 3)
-        
-        for i in range(int(n_face_to_delete)):
-            self.mesh.delete_face(self.mesh.face_handle(i))
-            
-        # =====================================================
-        # Check config afterwards
-        # =====================================================
-        
-        self.assertEqual(self.mesh.n_edges(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 24)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-        
-        # =====================================================
-        # Cleanup and recheck
-        # =====================================================
-        
-        self.mesh.garbage_collection()
-        
-        self.assertEqual(self.mesh.n_edges(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 24)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 3)
-        
-    def test_deletete_half_poly_mesh_cube_with_edge_status(self):
-        self.mesh = openmesh.PolyMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[5])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[6])
-        face_vhandles.append(self.vhandle[7])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[7])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 24)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-        
-        # =====================================================
-        # Now we delete half of the mesh
-        # =====================================================
-        self.mesh.request_face_status()
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_halfedge_status()
-        
-        n_face_to_delete = self.mesh.n_faces() / 2
-        
-        # Check the variable
-        self.assertEqual(n_face_to_delete, 3)
-        
-        for i in range(int(n_face_to_delete)):
-            self.mesh.delete_face(self.mesh.face_handle(i))
-            
-        # =====================================================
-        # Check config afterwards
-        # =====================================================
-        
-        self.assertEqual(self.mesh.n_edges(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 24)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 6)
-        
-        # =====================================================
-        # Cleanup and recheck
-        # =====================================================
-        
-        self.mesh.garbage_collection()
-        
-        self.assertEqual(self.mesh.n_edges(), 10)
-        self.assertEqual(self.mesh.n_halfedges(), 20)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 3)
-        
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(DeleteFaceTriangleMesh)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_property.py

@@ -1,289 +0,0 @@
-import unittest
-import openmesh
-
-class Property(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-
-    def test_vertex_property_copy_properties_int(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add two faces
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #  1 === 2
-        #  |   / |
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 4)
-        self.assertEqual(self.mesh.n_faces(), 2)
-        
-        # Add a vertex property
-        intHandle = openmesh.VPropHandle()
-        self.assertFalse(self.mesh.get_property_handle(intHandle, "intProp"))
-        self.mesh.add_property(intHandle, "intProp")
-        self.assertTrue(self.mesh.get_property_handle(intHandle, "intProp"))
-        
-        # Fill property
-        for vh in self.mesh.vertices():
-            self.mesh.set_property(intHandle, vh, vh.idx())
-        
-        # Check if property it is ok
-        v_it = self.mesh.vertices()
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 0)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 3)
-        
-        # Check vertex positions
-        v_it = self.mesh.vertices()
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        
-        # Copy from vertex 1 to 0, with skipping build in properties
-        self.mesh.copy_all_properties(self.vhandle[1], self.vhandle[0])
-        v_it = self.mesh.vertices()
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        v_it = self.mesh.vertices()
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 3)
-
-        # Copy from vertex 2 to 3, including build in properties
-        self.mesh.copy_all_properties(self.vhandle[2], self.vhandle[3], True)
-        v_it = self.mesh.vertices()
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        v_it = self.mesh.vertices()
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        
-    def test_check_status_properties_halfedge_edge_all_deleted(self):
-        self.mesh.request_vertex_status()
-        self.mesh.request_face_status()
-        self.mesh.request_halfedge_status()
-        self.mesh.request_edge_status()
-
-        # Define positions
-        p1 = openmesh.Vec3d(0, 0, 0)
-        p2 = openmesh.Vec3d(0, 1, 0)
-        p3 = openmesh.Vec3d(1, 1, 0)
-        p4 = openmesh.Vec3d(0, 0, 1)
-        
-        # Add some vertices
-        vh1 = self.mesh.add_vertex(p1)
-        vh2 = self.mesh.add_vertex(p2)
-        vh3 = self.mesh.add_vertex(p3)
-        vh4 = self.mesh.add_vertex(p4)
-
-        # Add some faces
-        f1 = self.mesh.add_face(vh1, vh3, vh2)
-        f2 = self.mesh.add_face(vh1, vh2, vh4)
-        f3 = self.mesh.add_face(vh2, vh3, vh4)
-        f4 = self.mesh.add_face(vh3, vh1, vh4)
-
-        # Delete all faces
-        self.mesh.delete_face(f1)
-        self.mesh.delete_face(f2)
-        self.mesh.delete_face(f3)
-        self.mesh.delete_face(f4)
-
-        for heh in self.mesh.halfedges():
-            self.assertTrue(self.mesh.status(self.mesh.edge_handle(heh)).deleted())
-            self.assertTrue(self.mesh.status(heh).deleted())
-
-    def test_copy_all_properties_vertex_after_remove_of_property(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add two faces
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #  1 === 2
-        #  |   / |
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 4)
-        self.assertEqual(self.mesh.n_faces(), 2)
-        
-        # Add a double vertex property
-        doubleHandle = openmesh.VPropHandle()
-        self.assertFalse(self.mesh.get_property_handle(doubleHandle, "doubleProp"))
-        self.mesh.add_property(doubleHandle, "doubleProp")
-        self.assertTrue(self.mesh.get_property_handle(doubleHandle, "doubleProp"))
-        
-        # Add a int vertex property
-        intHandle = openmesh.VPropHandle()
-        self.assertFalse(self.mesh.get_property_handle(intHandle, "intProp"))
-        self.mesh.add_property(intHandle, "intProp")
-        self.assertTrue(self.mesh.get_property_handle(intHandle, "intProp"))
-        
-        # Now remove the double property again
-        self.mesh.remove_property(doubleHandle)
-        
-        # Fill int property
-        for vh in self.mesh.vertices():
-            self.mesh.set_property(intHandle, vh, vh.idx())
-        
-        # Check if property it is ok
-        v_it = self.mesh.vertices()
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 0)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 3)
-
-        # Check vertex positions
-        v_it = self.mesh.vertices()
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-
-        # Copy from vertex 1 to 0, with skipping build in properties
-        self.mesh.copy_all_properties(self.vhandle[1], self.vhandle[0])
-        v_it = self.mesh.vertices()
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        v_it = self.mesh.vertices()
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 3)
-
-        # Copy from vertex 2 to 3, including build in properties
-        self.mesh.copy_all_properties(self.vhandle[2], self.vhandle[3], True)
-        v_it = self.mesh.vertices()
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 0)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 0)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        vh = v_it.next()
-        self.assertEqual(self.mesh.point(vh)[0], 1)
-        self.assertEqual(self.mesh.point(vh)[1], 1)
-        self.assertEqual(self.mesh.point(vh)[2], 0)
-        v_it = self.mesh.vertices()
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-        self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(Property)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_python.py

@@ -1,71 +0,0 @@
-import unittest
-import openmesh
-
-class Python(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-
-        # Add four faces using Python lists
-        vertex_list = [self.vhandle[0], self.vhandle[1], self.vhandle[2]]
-        self.mesh.add_face(vertex_list)
-        vertex_list = [self.vhandle[1], self.vhandle[3], self.vhandle[4]]
-        self.mesh.add_face(vertex_list)
-        vertex_list = [self.vhandle[0], self.vhandle[3], self.vhandle[1]]
-        self.mesh.add_face(vertex_list)
-        vertex_list = [self.vhandle[2], self.vhandle[1], self.vhandle[4]]
-        self.mesh.add_face(vertex_list)
-
-        # Test setup:
-        #  0 ==== 2
-        #  |\  0 /|
-        #  | \  / |
-        #  |2  1 3|
-        #  | /  \ |
-        #  |/  1 \|
-        #  3 ==== 4
-        
-    def test_python_iterator(self):
-        # Iterate over all vertices
-        indices = [0, 1, 2, 3, 4]
-        for v, idx in zip(self.mesh.vertices(), indices):
-            self.assertEqual(v.idx(), idx)
-
-    def test_python_circulator(self):
-        # Iterate around vertex 1 at the middle
-        indices = [4, 3, 0, 2]
-        for v, idx in zip(self.mesh.vv(self.vhandle[1]), indices):
-             self.assertEqual(v.idx(), idx)
-
-    def test_property_manager(self):
-        # Check if vertex property exists
-        self.assertFalse(openmesh.VPropertyManager.property_exists(self.mesh, "prop"))
-        
-        # Create a new vertex property
-        propman = openmesh.VPropertyManager(self.mesh, "prop")
-        self.assertTrue(propman.property_exists(self.mesh, "prop"))
-        
-        # Check initial property values
-        for v in self.mesh.vertices():
-            self.assertEqual(propman[v], None)
-        
-        # Set property values
-        propman.set_range(self.mesh.vertices(), 0.0)
-        
-        # Check again
-        for v in self.mesh.vertices():
-            self.assertEqual(propman[v], 0.0)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(Python)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_read_write_obj.py

@@ -1,229 +0,0 @@
-import unittest
-import openmesh
-
-class ReadWriteOBJ(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-    def test_load_simple_obj(self):
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal.obj")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-    def test_load_simple_obj_check_halfedge_and_vertex_normals(self):
-        self.mesh.request_halfedge_normals()
-        self.mesh.request_vertex_normals()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexNormal
-        
-        file_name = "cube-minimal.obj"
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        
-        # =====================================================
-        # Check vertex normals
-        # =====================================================
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[1], -1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[2],  0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[1],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[2],  1.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[1], -1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[2],  0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[1],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[2],  1.0)
-        
-        # =====================================================
-        # Check halfedge normals
-        # =====================================================
-        
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle( 0))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle( 0))[1],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle( 0))[2], -1.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(10))[0], -1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(10))[1],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(10))[2],  0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(19))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(19))[1],  1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(19))[2],  0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(24))[0],  1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(24))[1],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(24))[2],  0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(30))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(30))[1], -1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(30))[2],  0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(35))[0],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(35))[1],  0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.halfedge_handle(35))[2],  1.0)
-        
-        self.mesh.release_vertex_normals()
-        self.mesh.release_halfedge_normals()
-
-    def test_load_simple_obj_force_vertex_colors_although_not_available(self):
-        self.mesh.request_vertex_colors()
-        
-        file_name = "cube-minimal.obj"
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-
-    def test_load_simple_obj_check_texcoords(self):
-        self.mesh.request_halfedge_texcoords2D()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.FaceTexCoord
-        
-        file_name = "cube-minimal-texCoords.obj"
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle( 0))[0], 1.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle( 0))[1], 1.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(10))[0], 3.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(10))[1], 3.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(19))[0], 6.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(19))[1], 6.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(24))[0], 7.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(24))[1], 7.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(30))[0], 9.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(30))[1], 9.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(35))[0], 12.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.halfedge_handle(35))[1], 12.0)
-        
-        self.mesh.release_halfedge_texcoords2D()
-
-    def test_load_obj_with_material(self):
-        self.mesh.request_face_colors()
-
-        options = openmesh.Options()
-        options += openmesh.Options.FaceColor
-
-        file_name = "square_material.obj"
-
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-
-        self.assertTrue(ok)
-
-        fh = self.mesh.face_handle(self.mesh.halfedge_handle(0))
-
-        self.assertTrue(fh.is_valid())
-
-        self.assertAlmostEqual(self.mesh.color(fh)[0], 0.5, 2)
-        self.assertAlmostEqual(self.mesh.color(fh)[1], 0.5, 2)
-        self.assertAlmostEqual(self.mesh.color(fh)[2], 0.5, 2)
-
-        self.mesh.release_face_colors()
-
-    def test_load_simple_obj_with_vertex_colors_after_vertices(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        file_name = "cube-minimal-vertex-colors-after-vertex-definition.obj"
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 0.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 0.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.mesh.release_vertex_colors()
-
-    def test_load_simple_obj_with_vertex_colors_as_vc_lines(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        file_name = "cube-minimal-vertex-colors-as-vc-lines.obj"
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 0.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 0.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.mesh.release_vertex_colors()
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteOBJ)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_read_write_off.py

@@ -1,163 +0,0 @@
-import unittest
-import openmesh
-
-class ReadWriteOFF(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-    def test_load_simple_off_file(self):
-        ok = openmesh.read_mesh(self.mesh, "cube1.off")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 7526)
-        self.assertEqual(self.mesh.n_edges(), 22572)
-        self.assertEqual(self.mesh.n_faces(), 15048)
-
-    def test_write_and_read_vertex_colors_to_and_from_off_file(self):
-        self.mesh.request_vertex_colors()
-
-        self.mesh.add_vertex(openmesh.Vec3d(0, 0, 1))
-        self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0))
-        self.mesh.add_vertex(openmesh.Vec3d(0, 1, 1))
-        self.mesh.add_vertex(openmesh.Vec3d(1, 0, 1))
-        
-        # Using the default openmesh Python color type
-        testColor = openmesh.Vec4f(1.0, 0.5, 0.25, 1.0)
-        
-        # Setting colors (different from black)
-        for v in self.mesh.vertices():
-            self.mesh.set_color(v, testColor)
-        
-        # Check if the colors are correctly set
-        count = 0
-        for v in self.mesh.vertices():
-            color = self.mesh.color(v)
-            if color[0] != testColor[0] or color[1] != testColor[1] or color[2] != testColor[2]:
-                count += 1
-
-        self.assertEqual(count, 0)
-
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        options += openmesh.Options.ColorFloat
-        
-        openmesh.write_mesh(self.mesh, "temp.off", options)
-        openmesh.read_mesh(self.mesh, "temp.off", options)
-
-        # Check if vertices still have the same color
-        count = 0
-        for v in self.mesh.vertices():
-            color = self.mesh.color(v)
-            if color[0] != testColor[0] or color[1] != testColor[1] or color[2] != testColor[2]:
-                count += 1
-
-        self.assertEqual(count, 0)
-
-        self.mesh.release_vertex_colors()
-
-    def test_write_and_read_float_vertex_colors_to_and_from_off_file(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options(openmesh.Options.VertexColor)
-        
-        ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
-
-        self.assertTrue(ok)
-
-        options.clear()
-        options += openmesh.Options.VertexColor
-        options += openmesh.Options.ColorFloat
-
-        # Write the mesh
-        ok = openmesh.write_mesh(self.mesh, "cube_floating.off", options)
-        self.assertTrue(ok)
-        ok = openmesh.read_mesh(self.mesh, "cube_floating.off", options)
-        self.assertTrue(ok)
-
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-        self.assertTrue(options.color_is_float())
-
-        self.mesh.release_vertex_colors()
-
-    def test_write_and_read_binary_float_vertex_colors_to_and_from_off_file(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options(openmesh.Options.VertexColor)
-        
-        ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
-        
-        self.assertTrue(ok)
-        
-        options.clear()
-        options += openmesh.Options.VertexColor
-        options += openmesh.Options.Binary
-        options += openmesh.Options.ColorFloat
-        
-        # Write the mesh
-        ok = openmesh.write_mesh(self.mesh, "cube_floating_binary.off", options)
-        self.assertTrue(ok)
-        self.mesh.clear()
-        options.clear()
-        options += openmesh.Options.VertexColor
-        options += openmesh.Options.Binary
-        options += openmesh.Options.ColorFloat
-        ok = openmesh.read_mesh(self.mesh, "cube_floating_binary.off", options)
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertFalse(options.face_has_color())
-        self.assertTrue(options.vertex_has_color())
-        self.assertTrue(options.color_is_float())
-        self.assertTrue(options.is_binary())
-        
-        self.mesh.release_vertex_colors()
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteOFF)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_read_write_om.py

@@ -1,201 +0,0 @@
-import unittest
-import openmesh
-import os
-
-class ReadWriteOM(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-    def test_load_simple_om_force_vertex_colors_although_not_available(self):
-        self.mesh.request_vertex_colors()
-        
-        file_name = "cube-minimal.om"
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertFalse(options.vertex_has_color())
-
-    def test_load_simple_om_with_texcoords(self):
-        self.mesh.request_vertex_texcoords2D()
-
-        options = openmesh.Options()
-        options += openmesh.Options.VertexTexCoord
-        
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal-texCoords.om", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(0))[0], 10.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(0))[1], 10.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(2))[0], 6.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(2))[1], 6.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(4))[0], 9.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(4))[1], 9.0)
-        
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(7))[0], 12.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(7))[1], 12.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertTrue(options.vertex_has_texcoord())
-        self.assertFalse(options.vertex_has_color())
-        
-        self.mesh.release_vertex_texcoords2D()
-
-    def test_load_simple_om_with_vertex_colors(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal-vertexColors.om", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 0.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 0.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-        
-        self.mesh.release_vertex_colors()
-
-    def test_write_triangle(self):
-        filename = "triangle-minimal.om";
-        
-        # Generate data
-        v1 = self.mesh.add_vertex(openmesh.Vec3d(1.0, 0.0, 0.0))
-        v2 = self.mesh.add_vertex(openmesh.Vec3d(0.0, 1.0, 0.0))
-        v3 = self.mesh.add_vertex(openmesh.Vec3d(0.0, 0.0, 1.0))
-        self.mesh.add_face(v1, v2, v3)
-        
-        # Save
-        ok = openmesh.write_mesh(self.mesh, filename)
-        self.assertTrue(ok)
-        
-        # Reset
-        self.mesh.clear()
-        
-        # Load
-        ok = openmesh.read_mesh(self.mesh, filename)
-        self.assertTrue(ok)
-        
-        # Compare
-        self.assertEqual(self.mesh.n_vertices(), 3)
-        self.assertEqual(self.mesh.n_edges(), 3)
-        self.assertEqual(self.mesh.n_faces(), 1)
-        
-        self.assertEqual(self.mesh.point(v1), openmesh.Vec3d(1.0, 0.0, 0.0))
-        self.assertEqual(self.mesh.point(v2), openmesh.Vec3d(0.0, 1.0, 0.0))
-        self.assertEqual(self.mesh.point(v3), openmesh.Vec3d(0.0, 0.0, 1.0))
-        
-        # Cleanup
-        os.remove(filename)
-
-    def test_write_triangle_vertex_integer_color(self):
-        self.mesh.request_vertex_colors()
-            
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        options += openmesh.Options.ColorFloat
-
-        filename = "triangle-minimal-ColorsPerVertex.om"
-            
-        # Generate data
-        v1 = self.mesh.add_vertex(openmesh.Vec3d(1.0, 0.0, 0.0))
-        v2 = self.mesh.add_vertex(openmesh.Vec3d(0.0, 1.0, 0.0))
-        v3 = self.mesh.add_vertex(openmesh.Vec3d(0.0, 0.0, 1.0))
-        self.mesh.add_face(v1, v2, v3)
-        
-        c1 = openmesh.Vec4f(0.00, 0.00, 0.50, 1.00)
-        c2 = openmesh.Vec4f(0.25, 0.00, 0.00, 1.00)
-        c3 = openmesh.Vec4f(0.00, 0.75, 0.00, 1.00)
-    
-        self.mesh.set_color(v1, c1)
-        self.mesh.set_color(v2, c2)
-        self.mesh.set_color(v3, c3)
-            
-        # Save
-        ok = openmesh.write_mesh(self.mesh, filename, options)
-        self.assertTrue(ok)
-            
-        self.mesh.release_vertex_colors()
-            
-        # Load
-        cmpMesh = openmesh.TriMesh()
-        cmpMesh.request_vertex_colors()
-        ok = openmesh.read_mesh(cmpMesh, filename, options)
-        self.assertTrue(ok)
-            
-        self.assertTrue(cmpMesh.has_vertex_colors())
-            
-        # Compare
-        self.assertEqual(self.mesh.n_vertices(), 3)
-        self.assertEqual(self.mesh.n_edges(), 3)
-        self.assertEqual(self.mesh.n_faces(), 1)
-        
-        self.assertEqual(cmpMesh.point(v1), openmesh.Vec3d(1.0, 0.0, 0.0))
-        self.assertEqual(cmpMesh.point(v2), openmesh.Vec3d(0.0, 1.0, 0.0))
-        self.assertEqual(cmpMesh.point(v3), openmesh.Vec3d(0.0, 0.0, 1.0))
-        
-        self.assertAlmostEqual(cmpMesh.color(v1)[0], c1[0], 2)
-        self.assertAlmostEqual(cmpMesh.color(v1)[1], c1[1], 2)
-        self.assertAlmostEqual(cmpMesh.color(v1)[2], c1[2], 2)
-        self.assertAlmostEqual(cmpMesh.color(v1)[3], c1[3], 2)
-        
-        self.assertAlmostEqual(cmpMesh.color(v2)[0], c2[0], 2)
-        self.assertAlmostEqual(cmpMesh.color(v2)[1], c2[1], 2)
-        self.assertAlmostEqual(cmpMesh.color(v2)[2], c2[2], 2)
-        self.assertAlmostEqual(cmpMesh.color(v2)[3], c2[3], 2)
-        
-        self.assertAlmostEqual(cmpMesh.color(v3)[0], c3[0], 2)
-        self.assertAlmostEqual(cmpMesh.color(v3)[1], c3[1], 2)
-        self.assertAlmostEqual(cmpMesh.color(v3)[2], c3[2], 2)
-        self.assertAlmostEqual(cmpMesh.color(v3)[3], c3[3], 2)
-        
-        # Clean up
-        cmpMesh.release_vertex_colors()
-        os.remove(filename)
-
-    # TODO property tests
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteOM)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_read_write_ply.py

@@ -1,342 +0,0 @@
-import unittest
-import openmesh
-
-class ReadWritePLY(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-    def test_load_simple_point_ply_file_with_bad_encoding(self):
-        ok = openmesh.read_mesh(self.mesh, "pointCloudBadEncoding.ply")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 10)
-        self.assertEqual(self.mesh.n_edges(), 0)
-        self.assertEqual(self.mesh.n_faces(), 0)
-
-    def test_load_simple_point_ply_file_with_good_encoding(self):
-        ok = openmesh.read_mesh(self.mesh, "pointCloudGoodEncoding.ply")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 10)
-        self.assertEqual(self.mesh.n_edges(), 0)
-        self.assertEqual(self.mesh.n_faces(), 0)
-
-    def test_load_simple_ply(self):
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal.ply")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-    def test_load_simple_ply_force_vertex_colors_although_not_available(self):
-        self.mesh.request_vertex_colors()
-        
-        file_name = "cube-minimal.ply"
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, file_name, options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertFalse(options.vertex_has_color())
-
-    def test_load_simple_ply_with_vertex_colors(self):
-        self.mesh.request_vertex_colors()
-        
-        file_name = "cube-minimal.ply"
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal-vertexColors.ply", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-    
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 0.0)
-    
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 1.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 0.0)
-    
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-    
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-
-        self.mesh.release_vertex_colors()
-
-    def test_load_ply_from_mesh_lab_with_vertex_colors(self):
-        self.mesh.request_vertex_colors()
-    
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-    
-        ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
-    
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-    
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-    
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-    
-        self.mesh.release_vertex_colors()
-
-    def test_write_and_read_binary_ply_with_vertex_colors(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
-        
-        self.assertTrue(ok)
-
-        options += openmesh.Options.Binary
-
-        ok = openmesh.write_mesh(self.mesh, "meshlab_binary.ply", options)
-        self.assertTrue(ok)
-
-        self.mesh.clear
-
-        ok = openmesh.read_mesh(self.mesh, "meshlab_binary.ply", options)
-        self.assertTrue(ok)
-
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-    
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-    
-        self.mesh.release_vertex_colors()
-
-    def test_write_and_read_ply_with_float_vertex_colors(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
-        
-        self.assertTrue(ok)
-        
-        options += openmesh.Options.ColorFloat
-    
-        ok = openmesh.write_mesh(self.mesh, "meshlab_float.ply", options)
-        self.assertTrue(ok)
-        
-        self.mesh.clear
-        ok = openmesh.read_mesh(self.mesh, "meshlab_float.ply", options)
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-        self.assertTrue(options.color_is_float())
-        
-        self.mesh.release_vertex_colors()
-
-    def test_write_and_read_binary_ply_with_float_vertex_colors(self):
-        self.mesh.request_vertex_colors()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexColor
-        
-        ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
-        
-        self.assertTrue(ok)
-        
-        options += openmesh.Options.ColorFloat
-        options += openmesh.Options.Binary
-        
-        ok = openmesh.write_mesh(self.mesh, "meshlab_binary_float.ply", options)
-        self.assertTrue(ok)
-        
-        self.mesh.clear
-        ok = openmesh.read_mesh(self.mesh, "meshlab_binary_float.ply", options)
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
-        
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
-        self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertTrue(options.vertex_has_color())
-        self.assertTrue(options.color_is_float())
-        self.assertTrue(options.is_binary())
-        
-        self.mesh.release_vertex_colors()
-
-    def test_load_simple_ply_with_texcoords(self):
-        self.mesh.request_vertex_texcoords2D()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexTexCoord
-        
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal-texCoords.ply", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(0))[0], 10.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(0))[1], 10.0)
-
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(2))[0], 6.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(2))[1], 6.0)
-
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(4))[0], 9.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(4))[1], 9.0)
-
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(7))[0], 12.0)
-        self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(7))[1], 12.0)
-        
-        self.assertFalse(options.vertex_has_normal())
-        self.assertTrue(options.vertex_has_texcoord())
-        self.assertFalse(options.vertex_has_color())
-        
-        self.mesh.release_vertex_texcoords2D()
-
-    def test_load_simple_ply_with_normals(self):
-        self.mesh.request_vertex_normals()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.VertexNormal
-        
-        ok = openmesh.read_mesh(self.mesh, "cube-minimal-normals.ply", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.assertTrue(options.vertex_has_normal())
-        self.assertFalse(options.vertex_has_texcoord())
-        self.assertFalse(options.vertex_has_color())
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[0], 0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[1], 0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[2], 1.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[0], 1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[1], 0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[2], 0.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[0], 1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[1], 0.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[2], 1.0)
-        
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[0], 1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[1], 1.0)
-        self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[2], 2.0)
-        
-        self.mesh.release_vertex_normals()
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(ReadWritePLY)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_read_write_stl.py

@@ -1,75 +0,0 @@
-import unittest
-import openmesh
-
-class ReadWriteSTL(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-    def test_load_simple_stl_file(self):
-        ok = openmesh.read_mesh(self.mesh, "cube1.stl")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 7526)
-        self.assertEqual(self.mesh.n_edges(), 22572)
-        self.assertEqual(self.mesh.n_faces(), 15048)
-    
-    def test_load_simple_stl_file_with_normals(self):
-        self.mesh.request_face_normals()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.FaceNormal
-        
-        ok = openmesh.read_mesh(self.mesh, "cube1.stl", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[0], -0.038545)
-        self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[1], -0.004330)
-        self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[2],  0.999247)
-        
-        self.assertEqual(self.mesh.n_vertices(), 7526)
-        self.assertEqual(self.mesh.n_edges(), 22572)
-        self.assertEqual(self.mesh.n_faces(), 15048)
-        
-        self.mesh.release_face_normals()
-
-    def test_load_simple_stl_binary_file(self):
-        ok = openmesh.read_mesh(self.mesh, "cube1Binary.stl")
-        
-        self.assertTrue(ok)
-        
-        self.assertEqual(self.mesh.n_vertices(), 7526)
-        self.assertEqual(self.mesh.n_edges(), 22572)
-        self.assertEqual(self.mesh.n_faces(), 15048)
-
-    def test_load_simple_stl_binary_file_with_normals(self):
-        self.mesh.request_face_normals()
-        
-        options = openmesh.Options()
-        options += openmesh.Options.FaceNormal
-        options += openmesh.Options.Binary
-        
-        ok = openmesh.read_mesh(self.mesh, "cube1Binary.stl", options)
-        
-        self.assertTrue(ok)
-        
-        self.assertTrue(options.is_binary())
-        self.assertTrue(options.face_has_normal())
-        self.assertFalse(options.vertex_has_normal())
-        
-        self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[0], -0.038545, 5)
-        self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[1], -0.004330, 5)
-        self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[2],  0.999247, 5)
-        
-        self.assertEqual(self.mesh.n_vertices(), 7526)
-        self.assertEqual(self.mesh.n_edges(), 22572)
-        self.assertEqual(self.mesh.n_faces(), 15048)
-
-        self.mesh.release_face_normals()
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteSTL)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_split_copy.py

@@ -1,87 +0,0 @@
-import unittest
-import openmesh
-
-class SplitCopy(unittest.TestCase):
-
-    def test_split_copy_triangle_mesh(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0.25, 0.25, 0)))
-
-        # Add one face
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        
-        fh = self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #  1 === 2
-        #  |   /
-        #  |  /
-        #  | /
-        #  0
-        
-        # Set property
-        fprop_int = openmesh.FPropHandle()
-        self.mesh.add_property(fprop_int)
-        self.mesh.set_property(fprop_int, fh, 999)
-
-        # Split face with new vertex
-        self.mesh.split_copy(fh, self.vhandle[3])
-
-        # Check setup
-        for f in self.mesh.faces():
-            self.assertEqual(self.mesh.property(fprop_int, f), 999)
-
-    def test_split_copy_polymesh(self):
-        self.mesh = openmesh.PolyMesh()
-        self.vhandle = []
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0.5, 0.5, 0)))
-        
-        # Add one face
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        
-        fh = self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #  1 === 2
-        #  |     |
-        #  |     |
-        #  |     |
-        #  0 === 3
-        
-        # Set property
-        fprop_int = openmesh.FPropHandle()
-        self.mesh.add_property(fprop_int)
-        self.mesh.set_property(fprop_int, fh, 999)
-        
-        # Split face with new vertex
-        self.mesh.split_copy(fh, self.vhandle[4])
-        
-        # Check setup
-        for f in self.mesh.faces():
-            self.assertEqual(self.mesh.property(fprop_int, f), 999)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(SplitCopy)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_current_halfedge_handle_replacement.py

@@ -1,269 +0,0 @@
-import unittest
-import openmesh
-
-class TrimeshCirculatorCurrentHalfedgeHandleReplacement(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-    
-    def test_dereference(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-
-        # Add four faces
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[1])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #  0 ==== 2
-        #  |\  0 /|
-        #  | \  / |
-        #  |2  1 3|
-        #  | /  \ |
-        #  |/  1 \|
-        #  3 ==== 4
-        # Starting vertex is 1->4
-        
-        # output from fh_it.current_halfedge_handle()
-        current_halfedge_handles = [4, 0, 2, 10, 6, 8, 1, 12, 7, 14, 3, 11]
-        
-        i = 0
-        for f in self.mesh.faces():
-            for he in self.mesh.fh(f):
-                self.assertEqual(he.idx(), current_halfedge_handles[i])
-                i += 1
-
-    def test_vv_iter(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-        
-        # Add four faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[1])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #  0 ==== 2
-        #  |\  0 /|
-        #  | \  / |
-        #  |2  1 3|
-        #  | /  \ |
-        #  |/  1 \|
-        #  3 ==== 4
-        # Starting vertex is 1->4
-
-        # output from vv_it.current_halfedge_handle()
-        current_halfedge_handles = [5, 0, 12, 11, 6, 1, 2, 15, 3, 4, 13, 7, 8, 9, 10, 14]
-
-        eh0 = []
-        eh1 = []
-
-        i = 0
-
-        for v in self.mesh.vertices():
-            for vv in self.mesh.vv(v):
-                he = openmesh.HalfedgeHandle(current_halfedge_handles[i])
-                eh0.append(self.mesh.edge_handle(he))
-                i += 1
-        for v in self.mesh.vertices():
-            for he in self.mesh.voh(v):
-                eh1.append(self.mesh.edge_handle(he))
-
-        self.assertEqual(len(eh0), len(eh1))
-        for i in range(len(eh0)):
-            self.assertEqual(eh0[i], eh1[i])
-
-    def test_fe_iter(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-        
-        # Add four faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[1])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #  0 ==== 2
-        #  |\  0 /|
-        #  | \  / |
-        #  |2  1 3|
-        #  | /  \ |
-        #  |/  1 \|
-        #  3 ==== 4
-        # Starting vertex is 1->4
-        
-        # output from fe_it.current_halfedge_handle()
-        current_halfedge_handles = [4, 0, 2, 10, 6, 8, 1, 12, 7, 14, 3, 11]
-        
-        heh0 = []
-        heh1 = []
-        
-        i = 0
-        
-        for f in self.mesh.faces():
-            for e in self.mesh.fe(f):
-                heh0.append(openmesh.HalfedgeHandle(current_halfedge_handles[i]))
-                i += 1
-        for f in self.mesh.faces():
-            for he in self.mesh.fh(f):
-                heh1.append(he)
-        
-        self.assertEqual(len(heh0), len(heh1))
-        for i in range(len(heh0)):
-            self.assertEqual(heh0[i], heh1[i])
-
-    def test_vf_iter_boundary(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-        
-        # Add three faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        # 0 ------ 2 ------ 4
-        #  \      / \      /
-        #   \  0 /   \  1 /
-        #    \  /     \  /
-        #     1 ------- 3
-        #      \       /
-        #       \  2  /
-        #        \   /
-        #         \ /
-        #          5
-        
-        # output from fe_it.current_halfedge_handle()
-        current_halfedge_handles = [0, 2, 12, 4, 6, 8, 16, 10, 14]
-        
-        fh0 = []
-        fh1 = []
-        
-        i = 0
-        
-        for v in self.mesh.vertices():
-            for f in self.mesh.vf(v):
-                he = openmesh.HalfedgeHandle(current_halfedge_handles[i])
-                fh0.append(self.mesh.face_handle(he))
-                i += 1
-        for v in self.mesh.vertices():
-            for f in self.mesh.vf(v):
-                fh1.append(f)
-        
-        self.assertEqual(len(fh0), len(fh1))
-        for i in range(len(fh0)):
-            self.assertEqual(fh0[i], fh1[i])
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TrimeshCirculatorCurrentHalfedgeHandleReplacement)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_face_edge.py

@@ -1,50 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorFaceEdge(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[5], self.vhandle[3])
-
-        '''
-        Test setup:
-            0 ------ 2 ------ 4
-             \      / \      /
-              \  0 /   \  2 /
-               \  /  1  \  /
-                1 ------- 3
-                 \       /
-                  \  3  /
-                   \   /
-                    \ /
-                     5
-        '''
-
-    def test_face_edge_iter_without_holes_increment(self):
-        # Iterate around face 1 at the middle
-        fe_it = openmesh.FaceEdgeIter(self.mesh, self.mesh.face_handle(1))
-        self.assertEqual(fe_it.__next__().idx(), 4)
-        self.assertEqual(fe_it.__next__().idx(), 1)
-        self.assertEqual(fe_it.__next__().idx(), 3)
-        self.assertRaises(StopIteration, fe_it.__next__)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorFaceEdge)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_face_face.py

@@ -1,156 +0,0 @@
-import unittest
-import openmesh
-
-class TrimeshCirculatorFaceFace(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-    
-    def test_face_face_iter_with_holes(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 1, 0)))
-
-        # Add three faces
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #
-        # 0 ------ 2 ------ 4
-        #  \      / \      /
-        #   \  0 /   \  2 /
-        #    \  /  1  \  /
-        #     1 ------- 3
-
-        ff_it = self.mesh.ff(self.mesh.face_handle(1))
-
-        self.assertEqual(ff_it.__next__().idx(), 2)
-        self.assertEqual(ff_it.__next__().idx(), 0)
-        self.assertRaises(StopIteration, ff_it.__next__)
-
-    def test_face_face_iter_without_holes(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-        
-        # Add four faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        # 0 ------ 2 ------ 4
-        #  \      / \      /
-        #   \  0 /   \  2 /
-        #    \  /  1  \  /
-        #     1 ------- 3
-        #      \       /
-        #       \  3  /
-        #        \   /
-        #         \ /
-        #          5
-
-        ff_it = self.mesh.ff(self.mesh.face_handle(1))
-        
-        self.assertEqual(ff_it.__next__().idx(), 2)
-        self.assertEqual(ff_it.__next__().idx(), 0)
-        self.assertEqual(ff_it.__next__().idx(), 3)
-        self.assertRaises(StopIteration, ff_it.__next__)
-
-    def test_face_face_iter_without_holes(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add two faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        fh1 = self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        fh2 = self.mesh.add_face(face_vhandles)
-        
-        # Test setup:
-        #
-        #  1 -------- 2
-        #  | f0  /    |
-        #  |    / f1  |
-        #  0 -------- 3
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 4)
-        self.assertEqual(self.mesh.n_faces(), 2)
-
-        face_iter = self.mesh.ff(fh1)
-
-        # Get the face via the handle
-        faceHandle1 = face_iter.__next__()
-        face1 = self.mesh.face(faceHandle1)
-        
-        self.assertEqual(faceHandle1.idx(), 1)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TrimeshCirculatorFaceFace)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_face_halfedge.py

@@ -1,50 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorFaceHalfEdge(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[5], self.vhandle[3])
-
-        '''
-        Test setup:
-            0 ------ 2 ------ 4
-             \      / \      /
-              \  0 /   \  2 /
-               \  /  1  \  /
-                1 ------- 3
-                 \       /
-                  \  3  /
-                   \   /
-                    \ /
-                     5
-        '''
-
-    def test_face_halfedge_iter_without_holes_increment(self):
-        # Iterate around face 1 at the middle
-        fh_it = openmesh.FaceHalfedgeIter(self.mesh, self.mesh.face_handle(1))
-        self.assertEqual(fh_it.__next__().idx(), 8)
-        self.assertEqual(fh_it.__next__().idx(), 3)
-        self.assertEqual(fh_it.__next__().idx(), 6)
-        self.assertRaises(StopIteration, fh_it.__next__)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorFaceHalfEdge)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_face_vertex.py

@@ -1,48 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorFaceVertex(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        
-        # Add four faces
-        self.fh0 = self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        '''
-
-    def test_face_vertex_iter_without_increment(self):
-        self.assertEqual(self.fh0.idx(), 0)
-    
-        # Iterate around face 0 at the top
-        fv_it = openmesh.FaceVertexIter(self.mesh, self.fh0)
-        self.assertEqual(fv_it.__next__().idx(), 0)
-        self.assertEqual(fv_it.__next__().idx(), 1)
-        self.assertEqual(fv_it.__next__().idx(), 2)
-        self.assertRaises(StopIteration, fv_it.__next__)
-        
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorFaceVertex)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_halfedge_loop.py

@@ -1,131 +0,0 @@
-import unittest
-import openmesh
-
-class TrimeshCirculatorHalfedgeLoop(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-    
-    def test_halfedge_loop_with_face(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-
-        # Add four faces
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #
-        # edge x => halfedge x/x+1
-        # i.e. edge 0 => halfedge 0/1
-        #
-        # 0 --4--- 2 ------ 4
-        #  \      / \      /
-        #   0  0 2   6  2 /
-        #    \  /  1  \  /
-        #     1 ---8--- 3
-        #      \       /
-        #       \  3  /
-        #        \   /
-        #         \ /
-        #          5
-        
-        # Circle around face 1
-        hl_it = self.mesh.hl(self.mesh.halfedge_handle(3))
-
-        self.assertEqual(hl_it.__next__().idx(), 3)
-        self.assertEqual(hl_it.__next__().idx(), 6)
-        self.assertEqual(hl_it.__next__().idx(), 8)
-        self.assertRaises(StopIteration, hl_it.__next__)
-
-    def test_halfedge_loop_without_face(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
-        
-        # Add three faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #
-        # H => hole (no face)
-        # fx => face #x
-        # edge 0 => halfedge 0/1
-        #
-        # 0 --4--- 2 -10--- 4
-        #  \      / \      /
-        #   0 f0 2   6 f2 8
-        #    \  /  H  \  /
-        #     1 ---16---3
-        #      \       /
-        #      12 f3 14
-        #        \   /
-        #         \ /
-        #          5
-
-        # Circle around the hole
-        hl_it = self.mesh.hl(self.mesh.halfedge_handle(3))
-
-        self.assertEqual(hl_it.__next__().idx(), 3)
-        self.assertEqual(hl_it.__next__().idx(), 17)
-        self.assertEqual(hl_it.__next__().idx(), 7)
-        self.assertRaises(StopIteration, hl_it.__next__)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TrimeshCirculatorHalfedgeLoop)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_vertex_edge.py

@@ -1,55 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorVertexEdge(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        '''
-
-    def test_vertex_edge_iter_without_holes_increment(self):
-        # Iterate around vertex 1 at the middle
-        ve_it = openmesh.VertexEdgeIter(self.mesh, self.vhandle[1])
-        self.assertEqual(ve_it.__next__().idx(), 5)
-        self.assertEqual(ve_it.__next__().idx(), 3)
-        self.assertEqual(ve_it.__next__().idx(), 0)
-        self.assertEqual(ve_it.__next__().idx(), 1)
-        self.assertRaises(StopIteration, ve_it.__next__)
-        
-    def test_vertex_edge_iter_boundary_increment(self):
-        # Iterate around vertex 2 at the boundary
-        ve_it = openmesh.VertexEdgeIter(self.mesh, self.vhandle[2])
-        self.assertEqual(ve_it.__next__().idx(), 7)
-        self.assertEqual(ve_it.__next__().idx(), 1)
-        self.assertEqual(ve_it.__next__().idx(), 2)
-        self.assertRaises(StopIteration, ve_it.__next__)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexEdge)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_vertex_face.py

@@ -1,93 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorVertexFace(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-
-    def test_vertex_face_iter_with_holes_increment(self):
-        # Add two faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-             \    /
-              \  /
-                1
-              /  \
-             /    \
-            3 ==== 4
-        '''
-
-        # Iterate around vertex 1 at the middle (with holes in between)
-        vf_it = openmesh.VertexFaceIter(self.mesh, self.vhandle[1])
-        self.assertEqual(vf_it.__next__().idx(), 0)
-        self.assertEqual(vf_it.__next__().idx(), 1)
-        self.assertRaises(StopIteration, vf_it.__next__)
-
-    def test_vertex_face_iter_without_holes_increment(self):
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        '''
-        
-        # Iterate around vertex 1 at the middle (without holes in between)
-        vf_it = openmesh.VertexFaceIter(self.mesh, self.vhandle[1])
-        self.assertEqual(vf_it.__next__().idx(), 3)
-        self.assertEqual(vf_it.__next__().idx(), 1)
-        self.assertEqual(vf_it.__next__().idx(), 2)
-        self.assertEqual(vf_it.__next__().idx(), 0)
-        self.assertRaises(StopIteration, vf_it.__next__)
-        
-    def test_vertex_face_iter_boundary_increment(self):
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        '''
-        
-        # Iterate around vertex 2 at the boundary (without holes in between)
-        vf_it = openmesh.VertexFaceIter(self.mesh, self.vhandle[2])
-        self.assertEqual(vf_it.__next__().idx(), 3)
-        self.assertEqual(vf_it.__next__().idx(), 0)
-        self.assertRaises(StopIteration, vf_it.__next__)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexFace)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_vertex_ihalfedge.py

@@ -1,80 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorVertexIHalfEdge(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        Starting halfedge is 1->4
-        '''
-
-    def test_vertex_incoming_halfedge_without_holes_increment(self):
-        # Iterate around vertex 1 at the middle
-        vih_it = openmesh.VertexIHalfedgeIter(self.mesh, self.vhandle[1])
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 10)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 1)
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 7)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 2)
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 0)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 3)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
-        self.assertRaises(StopIteration, vih_it.__next__)
-        
-    def test_vertex_incoming_halfedge_boundary_increment(self):
-        # Iterate around vertex 2 at the boundary
-        vih_it = openmesh.VertexIHalfedgeIter(self.mesh, self.vhandle[2])
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 14)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 2)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
-        heh = vih_it.__next__()
-        self.assertEqual(heh.idx(), 5)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), -1)
-        self.assertRaises(StopIteration, vih_it.__next__)
-        
-    def test_vertex_incoming_halfedge_dereference_increment(self):
-        # Iterate around vertex 1 at the middle
-        vih_it = openmesh.VertexIHalfedgeIter(self.mesh, self.vhandle[1])
-        heh = vih_it.__next__()
-        eh = self.mesh.edge_handle(heh)
-        vh = self.mesh.to_vertex_handle(heh)
-        self.assertEqual(heh.idx(), 10)
-        self.assertEqual(eh.idx(), 5)
-        self.assertEqual(vh.idx(), 1)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexIHalfEdge)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_vertex_ohalfedge.py

@@ -1,80 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorVertexOHalfEdge(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-        
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        Starting halfedge is 1->4
-        '''
-
-    def test_vertex_outgoing_halfedge_without_holes_increment(self):
-        # Iterate around vertex 1 at the middle
-        voh_it = openmesh.VertexOHalfedgeIter(self.mesh, self.vhandle[1])
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 11)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 6)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 1)
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 1)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 2)
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 2)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
-        self.assertRaises(StopIteration, voh_it.__next__)
-        
-    def test_vertex_outgoing_halfedge_boundary_increment(self):
-        # Iterate around vertex 2 at the boundary
-        voh_it = openmesh.VertexOHalfedgeIter(self.mesh, self.vhandle[2])
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 15)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), -1)
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 3)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
-        heh = voh_it.__next__()
-        self.assertEqual(heh.idx(), 4)
-        self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
-        self.assertRaises(StopIteration, voh_it.__next__)
-        
-    def test_vertex_outgoing_halfedge_dereference_increment(self):
-        # Iterate around vertex 1 at the middle
-        voh_it = openmesh.VertexOHalfedgeIter(self.mesh, self.vhandle[1])
-        heh = voh_it.__next__()
-        eh = self.mesh.edge_handle(heh)
-        vh = self.mesh.to_vertex_handle(heh)
-        self.assertEqual(heh.idx(), 11)
-        self.assertEqual(eh.idx(), 5)
-        self.assertEqual(vh.idx(), 4)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexOHalfEdge)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_circulator_vertex_vertex.py

@@ -1,56 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshCirculatorVertexVertex(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-
-        # Add some vertices
-        self.vhandle = []
-
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
-
-        # Add four faces
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
-
-        '''
-        Test setup:
-            0 ==== 2
-            |\  0 /|
-            | \  / |
-            |2  1 3|
-            | /  \ |
-            |/  1 \|
-            3 ==== 4
-        Starting vertex is 1->4
-        '''
-
-    def test_vertex_vertex_increment(self):
-        # Iterate around vertex 1 at the middle
-        vv_it = openmesh.VertexVertexIter(self.mesh, self.vhandle[1])
-        self.assertEqual(vv_it.__next__().idx(), 4)
-        self.assertEqual(vv_it.__next__().idx(), 3)
-        self.assertEqual(vv_it.__next__().idx(), 0)
-        self.assertEqual(vv_it.__next__().idx(), 2)
-        self.assertRaises(StopIteration, vv_it.__next__)
-
-    def test_vertex_vertex_boundary_increment(self):
-        # Iterate around vertex 2 at the boundary
-        vv_it = openmesh.VertexVertexIter(self.mesh, self.vhandle[2])
-        self.assertEqual(vv_it.__next__().idx(), 4)
-        self.assertEqual(vv_it.__next__().idx(), 1)
-        self.assertEqual(vv_it.__next__().idx(), 0)
-        self.assertRaises(StopIteration, vv_it.__next__)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexVertex)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_collapse.py

@@ -1,516 +0,0 @@
-import unittest
-import openmesh
-
-class Collapse(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-    
-    def test_collapse_quad_with_center(self):
-        
-        # 0--------1
-        # |\      /|
-        # | \    / |
-        # |  \  /  |
-        # |    2   |
-        # |  /  \  |
-        # | /    \ |
-        # 3--------4
-
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 2, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 2, 0)))
-
-        # Add four faces
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_face_status()
-
-        # Get the halfedge
-        v2v1 = self.mesh.find_halfedge(self.vhandle[2], self.vhandle[1])
-
-        self.assertTrue(v2v1.is_valid())
-        self.assertTrue(self.mesh.is_collapse_ok(v2v1))
-
-        # Execute it as a crash test
-        self.mesh.collapse(v2v1)
-
-    def test_collapse_tetrahedron_complex(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add four faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        self.mesh.add_face(face_vhandles)
-        
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_face_status()
-        
-        v0v1 = self.mesh.halfedge_handle(0)
-        v1v0 = self.mesh.opposite_halfedge_handle(v0v1)
-
-        v1vL = self.mesh.next_halfedge_handle(v0v1)
-        vLv1 = self.mesh.opposite_halfedge_handle(v1vL)
-        vLv0 = self.mesh.next_halfedge_handle(v1vL)
-        v0vL = self.mesh.opposite_halfedge_handle(vLv0)
-
-        vLvR = self.mesh.next_halfedge_handle(v0vL)
-        vRvL = self.mesh.opposite_halfedge_handle(vLvR)
-
-        v0vR = self.mesh.next_halfedge_handle(v1v0)
-        vRv0 = self.mesh.opposite_halfedge_handle(v0vR)
-        vRv1 = self.mesh.next_halfedge_handle(v0vR)
-        v1vR = self.mesh.opposite_halfedge_handle(vRv1)
-
-        v0 = self.mesh.from_vertex_handle(v0v1)
-        v1 = self.mesh.to_vertex_handle(v0v1)
-        vL = self.mesh.to_vertex_handle(self.mesh.next_halfedge_handle(v0v1))
-        vR = self.mesh.to_vertex_handle(self.mesh.next_halfedge_handle(v1v0))
-
-        # ===================================================================
-        # Check preconditions
-        # ===================================================================
-
-        self.assertTrue(self.mesh.is_collapse_ok(v0v1))
-        self.assertTrue(self.mesh.is_collapse_ok(v1v0))
-
-        # Test the Vertex indices
-        self.assertEqual(v0.idx(), 0)
-        self.assertEqual(v1.idx(), 1)
-        self.assertEqual(vL.idx(), 2)
-        self.assertEqual(vR.idx(), 3)
-
-        # Check the halfedges
-        self.assertEqual(v0v1.idx(), 0)
-        self.assertEqual(v1v0.idx(), 1)
-        
-        self.assertEqual(v1vL.idx(), 2)
-        self.assertEqual(vLv1.idx(), 3)
-        self.assertEqual(vLv0.idx(), 4)
-        self.assertEqual(v0vL.idx(), 5)
-        
-        self.assertEqual(vLvR.idx(), 6)
-        self.assertEqual(vRvL.idx(), 7)
-        
-        self.assertEqual(vRv0.idx(), 8)
-        self.assertEqual(v0vR.idx(), 9)
-        
-        self.assertEqual(v1vR.idx(), 10)
-        self.assertEqual(vRv1.idx(), 11)
-
-        # ===================================================================
-        # Execute collapse
-        # ===================================================================
-
-        self.mesh.collapse(v0v1)
-
-        # ===================================================================
-        # Check configuration afterwards
-        # ===================================================================
-
-        # Now the configuration should look like this:
-        # The numbers at the side denote the halfedges
-        #          1
-        #         / \
-        #        /   \
-        #      //    \\
-        #     3/2    11\10
-        #     //        \\
-        #    /    6-->   \
-        #   2 ----------- 3
-        #       <--7
-
-        self.assertEqual(self.mesh.n_faces(), 4)
-
-        # Check if the right vertices got deleted
-        self.assertTrue(self.mesh.status(self.mesh.face_handle(0)).deleted())
-        self.assertFalse(self.mesh.status(self.mesh.face_handle(1)).deleted())
-        self.assertFalse(self.mesh.status(self.mesh.face_handle(2)).deleted())
-        self.assertTrue(self.mesh.status(self.mesh.face_handle(3)).deleted())
-
-        # Check the vertices of the two remaining faces
-        fh_1 = self.mesh.face_handle(1)
-        fh_2 = self.mesh.face_handle(2)
-
-        fv_it = self.mesh.fv(fh_1)
-
-        self.assertTrue(fv_it.__next__().idx(), 1)
-        self.assertTrue(fv_it.__next__().idx(), 2)
-        self.assertTrue(fv_it.__next__().idx(), 3)
-
-        fv_it = self.mesh.fv(fh_2)
-
-        self.assertTrue(fv_it.__next__().idx(), 2)
-        self.assertTrue(fv_it.__next__().idx(), 1)
-        self.assertTrue(fv_it.__next__().idx(), 3)
-
-        # Get the first halfedge of face 1
-        fh_1_he = self.mesh.halfedge_handle(fh_1)
-
-        self.assertEqual(fh_1_he.idx(), 11)
-        self.assertEqual(self.mesh.to_vertex_handle(fh_1_he).idx(), 1)
-
-        next = self.mesh.next_halfedge_handle(fh_1_he)
-        self.assertEqual(next.idx(), 2)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 2)
-
-        next = self.mesh.next_halfedge_handle(next)
-        self.assertEqual(next.idx(), 6)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 3)
-
-        # Get the first halfedge of face 2
-        fh_2_he = self.mesh.halfedge_handle(fh_2)
-
-        self.assertEqual(fh_2_he.idx(), 7)
-        self.assertEqual(self.mesh.to_vertex_handle(fh_2_he).idx(), 2)
-
-        next = self.mesh.next_halfedge_handle(fh_2_he)
-        self.assertEqual(next.idx(), 3)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 1)
-
-        next = self.mesh.next_halfedge_handle(next)
-        self.assertEqual(next.idx(), 10)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 3)
-
-        # Vertex 1 outgoing
-        voh_it = self.mesh.voh(self.mesh.vertex_handle(1))
-        self.assertEqual(voh_it.__next__().idx(), 10)
-        self.assertEqual(voh_it.__next__().idx(), 2)
-        self.assertRaises(StopIteration, voh_it.__next__)
-
-        # Vertex 2 outgoing
-        voh_it = self.mesh.voh(self.mesh.vertex_handle(2))
-        self.assertEqual(voh_it.__next__().idx(), 3)
-        self.assertEqual(voh_it.__next__().idx(), 6)
-        self.assertRaises(StopIteration, voh_it.__next__)
-
-        # Vertex 2 outgoing
-        voh_it = self.mesh.voh(self.mesh.vertex_handle(3))
-        self.assertEqual(voh_it.__next__().idx(), 11)
-        self.assertEqual(voh_it.__next__().idx(), 7)
-        self.assertRaises(StopIteration, voh_it.__next__)
-
-        # ===================================================================
-        # Cleanup
-        # ===================================================================
-        self.mesh.garbage_collection()
-
-        # ===================================================================
-        # Check configuration afterwards
-        # ===================================================================
-
-        # Now the configuration should look like this:
-        # The numbers at the side denote the halfedges
-        #          0
-        #         / \
-        #        /   \
-        #      //    \\
-        #     4/5     0\1
-        #     //        \\
-        #    /    3-->   \
-        #   2 ----------- 1
-        #       <--2
-
-        self.assertEqual(self.mesh.n_faces(), 2)
-
-        # Check the vertices of the two remaining faces
-        fh_0 = self.mesh.face_handle(0)
-        fh_1 = self.mesh.face_handle(1)
-
-        fv_it = self.mesh.fv(fh_0)
-
-        self.assertEqual(fv_it.__next__().idx(), 2)
-        self.assertEqual(fv_it.__next__().idx(), 1)
-        self.assertEqual(fv_it.__next__().idx(), 0)
-
-        fv_it = self.mesh.fv(fh_1)
-
-        self.assertEqual(fv_it.__next__().idx(), 1)
-        self.assertEqual(fv_it.__next__().idx(), 2)
-        self.assertEqual(fv_it.__next__().idx(), 0)
-
-        # Get the first halfedge of face 1
-        fh_0_he = self.mesh.halfedge_handle(fh_0)
-
-        self.assertEqual(fh_0_he.idx(), 5)
-        self.assertEqual(self.mesh.to_vertex_handle(fh_0_he).idx(), 2)
-
-        next = self.mesh.next_halfedge_handle(fh_0_he)
-        self.assertEqual(next.idx(), 3)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 1)
-
-        next = self.mesh.next_halfedge_handle(next)
-        self.assertEqual(next.idx(), 0)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 0)
-
-        # Get the first halfedge of face 1
-        fh_1_he = self.mesh.halfedge_handle(fh_1)
-
-        self.assertEqual(fh_1_he.idx(), 1)
-        self.assertEqual(self.mesh.to_vertex_handle(fh_1_he).idx(), 1)
-
-        next = self.mesh.next_halfedge_handle(fh_1_he)
-        self.assertEqual(next.idx(), 2)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 2)
-
-        next = self.mesh.next_halfedge_handle(next)
-        self.assertEqual(next.idx(), 4)
-        self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 0)
-
-        # Vertex 0 outgoing
-        voh_it = self.mesh.voh(self.mesh.vertex_handle(0))
-        self.assertEqual(voh_it.__next__().idx(), 1)
-        self.assertEqual(voh_it.__next__().idx(), 5)
-        self.assertRaises(StopIteration, voh_it.__next__)
-
-        # Vertex 1 outgoing
-        voh_it = self.mesh.voh(self.mesh.vertex_handle(1))
-        self.assertEqual(voh_it.__next__().idx(), 0)
-        self.assertEqual(voh_it.__next__().idx(), 2)
-        self.assertRaises(StopIteration, voh_it.__next__)
-
-        # Vertex 2 outgoing
-        voh_it = self.mesh.voh(self.mesh.vertex_handle(2))
-        self.assertEqual(voh_it.__next__().idx(), 3)
-        self.assertEqual(voh_it.__next__().idx(), 4)
-        self.assertRaises(StopIteration, voh_it.__next__)
-
-        self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(0)))
-        self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(1)))
-        self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(2)))
-        self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(3)))
-        self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(4)))
-        self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(5)))
-
-    def test_collapse_tetrahedron(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0, -1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  0, 0)))
-        
-        # Add six faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[0])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_face_status()
-
-        # =============================================
-        # Collapse halfedge from 0 to 4
-        # =============================================
-
-        heh_collapse1 = self.mesh.halfedge_handle(0)
-
-        self.assertEqual(self.mesh.to_vertex_handle(heh_collapse1).idx(), 4)
-        self.assertEqual(self.mesh.from_vertex_handle(heh_collapse1).idx(), 0)
-
-        self.assertTrue(self.mesh.is_collapse_ok(heh_collapse1))
-        self.mesh.collapse(heh_collapse1)
-
-        heh_collapse2 = self.mesh.halfedge_handle(2)
-
-        self.assertEqual(self.mesh.to_vertex_handle(heh_collapse2).idx(), 2)
-        self.assertEqual(self.mesh.from_vertex_handle(heh_collapse2).idx(), 4)
-
-        self.assertTrue(self.mesh.is_collapse_ok(heh_collapse2))
-        self.mesh.collapse(heh_collapse2)
-
-        heh_collapse3 = self.mesh.halfedge_handle(6)
-
-        self.assertEqual(self.mesh.to_vertex_handle(heh_collapse3).idx(), 2)
-        self.assertEqual(self.mesh.from_vertex_handle(heh_collapse3).idx(), 3)
-
-        self.assertFalse(self.mesh.is_collapse_ok(heh_collapse3))
-
-    def test_large_collapse_halfedge(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 2,  1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0, -1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 2, -1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 3,  0, 0)))
-        
-        # Add six faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[1])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[5])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[4])
-        self.mesh.add_face(face_vhandles)
-
-        face_vhandles = []
-
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[4])
-        face_vhandles.append(self.vhandle[6])
-        self.mesh.add_face(face_vhandles)
-
-        # Test setup:
-        #    0 ==== 2
-        #   / \    /|\
-        #  /   \  / | \
-        # 5 --- 1   |  6
-        #  \   /  \ | /
-        #   \ /    \|/
-        #    3 ==== 4
-
-        # Request the status bits
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_face_status()
-
-        # =============================================
-        # Collapse halfedge from 1 to 4
-        # =============================================
-
-        heh_collapse = openmesh.HalfedgeHandle()
-
-        for he in self.mesh.halfedges():
-            if self.mesh.from_vertex_handle(he).idx() == 1 and self.mesh.to_vertex_handle(he).idx() == 4:
-                heh_collapse = he
-
-        # Check our halfedge
-        self.assertEqual(self.mesh.to_vertex_handle(heh_collapse).idx(), 4)
-        self.assertEqual(self.mesh.from_vertex_handle(heh_collapse).idx(), 1)
-        self.assertTrue(self.mesh.is_collapse_ok(heh_collapse))
-
-        # Remember the end vertices
-        vh_from = self.mesh.from_vertex_handle(heh_collapse)
-        vh_to = self.mesh.to_vertex_handle(heh_collapse)
-
-        # Collapse it
-        self.mesh.collapse(heh_collapse)
-
-        self.assertTrue(self.mesh.status(vh_from).deleted())
-        self.assertFalse(self.mesh.status(vh_to).deleted())
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(Collapse)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_garbage_collection.py

@@ -1,168 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshGarbageCollection(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_halfedge_status()
-        self.mesh.request_face_status()
-
-        # Add some vertices
-        self.vhandle = []
-        
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-
-        # Add six faces to form a cube
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[2], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[7], self.vhandle[6], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[7], self.vhandle[5], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[0], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[4], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[5], self.vhandle[6])
-        self.mesh.add_face(self.vhandle[3], self.vhandle[2], self.vhandle[6])
-        self.mesh.add_face(self.vhandle[3], self.vhandle[6], self.vhandle[7])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[7])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[7], self.vhandle[4])
-
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-    def test_standard_garbage_collection(self):
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.mesh.delete_vertex(self.vhandle[0])
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        self.mesh.garbage_collection()
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 7)
-        self.assertEqual(self.mesh.n_faces(), 8)
-        
-    def test_tracked_garbage_collection(self):
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-        #==================================================
-        # Create lists containing the current handles
-        #==================================================
-
-        vertexHandles = []
-        for v in self.mesh.vertices():
-            vertexHandles.append(v)
-
-        halfedgeHandles = []
-        for he in self.mesh.halfedges():
-            halfedgeHandles.append(he)
-
-        faceHandles = []
-        for f in self.mesh.faces():
-            faceHandles.append(f)
-
-        # Deleting vertex 0
-        self.mesh.delete_vertex(self.vhandle[0])
-
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-
-        self.mesh.garbage_collection(vertexHandles, halfedgeHandles, faceHandles, True, True, True)
-
-        # Check setup
-        self.assertEqual(self.mesh.n_vertices(), 7)
-        self.assertEqual(self.mesh.n_faces(), 8)
-
-        # Check setup of vertices
-        self.assertEqual(vertexHandles[0].idx(), -1)
-        self.assertEqual(vertexHandles[1].idx(),  1)
-        self.assertEqual(vertexHandles[2].idx(),  2)
-        self.assertEqual(vertexHandles[3].idx(),  3)
-        self.assertEqual(vertexHandles[4].idx(),  4)
-        self.assertEqual(vertexHandles[5].idx(),  5)
-        self.assertEqual(vertexHandles[6].idx(),  6)
-        self.assertEqual(vertexHandles[7].idx(),  0)
-
-        # Check setup of halfedge handles
-        self.assertEqual(halfedgeHandles[0 ].idx(), -1)
-        self.assertEqual(halfedgeHandles[1 ].idx(), -1)
-        self.assertEqual(halfedgeHandles[2 ].idx(),  2)
-        self.assertEqual(halfedgeHandles[3 ].idx(),  3)
-        self.assertEqual(halfedgeHandles[4 ].idx(), -1)
-        self.assertEqual(halfedgeHandles[5 ].idx(), -1)
-        self.assertEqual(halfedgeHandles[6 ].idx(),  6)
-        self.assertEqual(halfedgeHandles[7 ].idx(),  7)
-        self.assertEqual(halfedgeHandles[8 ].idx(),  8)
-        self.assertEqual(halfedgeHandles[9 ].idx(),  9)
-        self.assertEqual(halfedgeHandles[10].idx(), 10)
-        self.assertEqual(halfedgeHandles[11].idx(), 11)
-        self.assertEqual(halfedgeHandles[12].idx(), 12)
-        self.assertEqual(halfedgeHandles[13].idx(), 13)
-        self.assertEqual(halfedgeHandles[14].idx(), 14)
-        self.assertEqual(halfedgeHandles[15].idx(), 15)
-        self.assertEqual(halfedgeHandles[16].idx(), 16)
-        self.assertEqual(halfedgeHandles[17].idx(), 17)
-        self.assertEqual(halfedgeHandles[18].idx(), 18)
-        self.assertEqual(halfedgeHandles[19].idx(), 19)
-        self.assertEqual(halfedgeHandles[20].idx(), -1)
-        self.assertEqual(halfedgeHandles[21].idx(), -1)
-        self.assertEqual(halfedgeHandles[22].idx(), 22)
-        self.assertEqual(halfedgeHandles[23].idx(), 23)
-        self.assertEqual(halfedgeHandles[24].idx(), 24)
-        self.assertEqual(halfedgeHandles[25].idx(), 25)
-        self.assertEqual(halfedgeHandles[26].idx(), 26)
-        self.assertEqual(halfedgeHandles[27].idx(), 27)
-        self.assertEqual(halfedgeHandles[28].idx(), 20)
-        self.assertEqual(halfedgeHandles[29].idx(), 21)
-        self.assertEqual(halfedgeHandles[30].idx(),  4)
-        self.assertEqual(halfedgeHandles[31].idx(),  5)
-        self.assertEqual(halfedgeHandles[32].idx(),  0)
-        self.assertEqual(halfedgeHandles[33].idx(),  1)
-        self.assertEqual(halfedgeHandles[34].idx(), -1)
-        self.assertEqual(halfedgeHandles[35].idx(), -1)
-
-        # Check setup of faces
-        self.assertEqual(faceHandles[0 ].idx(), -1)
-        self.assertEqual(faceHandles[1 ].idx(),  1)
-        self.assertEqual(faceHandles[2 ].idx(),  2)
-        self.assertEqual(faceHandles[3 ].idx(),  3)
-        self.assertEqual(faceHandles[4 ].idx(), -1)
-        self.assertEqual(faceHandles[5 ].idx(),  5)
-        self.assertEqual(faceHandles[6 ].idx(),  6)
-        self.assertEqual(faceHandles[7 ].idx(),  7)
-        self.assertEqual(faceHandles[8 ].idx(),  4)
-        self.assertEqual(faceHandles[9 ].idx(),  0)
-        self.assertEqual(faceHandles[10].idx(), -1)
-        self.assertEqual(faceHandles[11].idx(), -1)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshGarbageCollection)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_iterators.py

@@ -1,396 +0,0 @@
-import unittest
-import openmesh
-
-class TriMeshIterators(unittest.TestCase):
-
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        self.vhandle = []
-
-    def test_vertex_iter(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add two faces
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[0])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[0], self.vhandle[3])
-        
-        # Test setup:
-        #  1 === 2
-        #  |   / |    
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        v_it = self.mesh.vertices()
-        
-        self.assertEqual(v_it.__next__().idx(), 0)
-        self.assertEqual(v_it.__next__().idx(), 1)
-        self.assertEqual(v_it.__next__().idx(), 2)
-        self.assertEqual(v_it.__next__().idx(), 3)
-        
-        self.assertRaises(StopIteration, v_it.__next__)
-        
-    def test_vertex_iter_start_position(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add two faces
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[0])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[0], self.vhandle[3])
-        
-        # Test setup:
-        #  1 === 2
-        #  |   / |    
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        v_it = openmesh.VertexIter(self.mesh, self.mesh.vertex_handle(2))
-        
-        self.assertEqual(v_it.__next__().idx(), 2)
-        self.assertEqual(v_it.__next__().idx(), 3)
-        
-        self.assertRaises(StopIteration, v_it.__next__)
-        
-    def test_edge_iter(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
-        
-        # Add two faces
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[0])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[0], self.vhandle[3])
-        
-        # Test setup:
-        #  1 === 2
-        #  |   / |    
-        #  |  /  |
-        #  | /   |
-        #  0 === 3
-        
-        e_it = self.mesh.edges()
-        
-        e = e_it.__next__()
-        self.assertEqual(e.idx(), 0)
-        
-        he = self.mesh.halfedge_handle(e, 0)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 1)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
-        he = self.mesh.halfedge_handle(e, 1)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 2)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 1)
-        
-        e = e_it.__next__()
-        self.assertEqual(e.idx(), 1)
-        
-        he = self.mesh.halfedge_handle(e, 0)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 1)
-        he = self.mesh.halfedge_handle(e, 1)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 1)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 0)
-        
-        e = e_it.__next__()
-        self.assertEqual(e.idx(), 2)
-        
-        he = self.mesh.halfedge_handle(e, 0)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 2)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 0)
-        he = self.mesh.halfedge_handle(e, 1)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
-        
-        e = e_it.__next__()
-        self.assertEqual(e.idx(), 3)
-        
-        he = self.mesh.halfedge_handle(e, 0)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 3)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 0)
-        he = self.mesh.halfedge_handle(e, 1)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 3)
-        
-        e = e_it.__next__()
-        self.assertEqual(e.idx(), 4)
-        
-        he = self.mesh.halfedge_handle(e, 0)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 2)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 3)
-        he = self.mesh.halfedge_handle(e, 1)
-        self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 3)
-        self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
-    
-    def test_halfedge_iter_skipping(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[2], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[7], self.vhandle[6], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[7], self.vhandle[5], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[0], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[4], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[5], self.vhandle[6])
-        self.mesh.add_face(self.vhandle[3], self.vhandle[2], self.vhandle[6])
-        self.mesh.add_face(self.vhandle[3], self.vhandle[6], self.vhandle[7])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[7])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[7], self.vhandle[4])
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # Run over all halfedges
-        heCounter = 0
-
-        self.mesh.request_face_status()
-        self.mesh.request_vertex_status()
-        self.mesh.request_halfedge_status()
-        
-        # Get second edge
-        eh = self.mesh.edge_handle(2)
-        
-        # Delete one edge
-        self.mesh.delete_edge(eh)
-        
-        # Check setup ( No garbage collection, so nothing should change!)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # =====================================================
-        # Check skipping iterator
-        # =====================================================
-        
-        ok_4 = True
-        ok_5 = True
-        
-        count = 0
-        
-        for he in self.mesh.shalfedges():
-            if he.idx() == 4:
-                ok_4 = False
-            if he.idx() == 5:
-                ok_5 = False
-            count += 1
-        
-        self.assertEqual(count, 34)
-        self.assertTrue(ok_4)
-        self.assertTrue(ok_5)
-        
-        # =====================================================
-        # Check non skipping iterator
-        # =====================================================
-        
-        ok_4 = False
-        ok_5 = False
-        
-        count = 0
-        
-        for he in self.mesh.halfedges():
-            if he.idx() == 4:
-                ok_4 = True
-            if he.idx() == 5:
-                ok_5 = True
-            count += 1
-        
-        self.assertEqual(count, 36)
-        self.assertTrue(ok_4)
-        self.assertTrue(ok_5)
-        
-    def test_halfedge_iter_skipping_low_level(self):
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1,  1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1,  1, -1)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1,  1, -1)))
-        
-        # Add six faces to form a cube
-        self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[2], self.vhandle[3])
-        self.mesh.add_face(self.vhandle[7], self.vhandle[6], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[7], self.vhandle[5], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[0], self.vhandle[4])
-        self.mesh.add_face(self.vhandle[1], self.vhandle[4], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[5])
-        self.mesh.add_face(self.vhandle[2], self.vhandle[5], self.vhandle[6])
-        self.mesh.add_face(self.vhandle[3], self.vhandle[2], self.vhandle[6])
-        self.mesh.add_face(self.vhandle[3], self.vhandle[6], self.vhandle[7])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[7])
-        self.mesh.add_face(self.vhandle[0], self.vhandle[7], self.vhandle[4])
-        
-        # Test setup:
-        #
-        #    3 ======== 2
-        #   /          /|
-        #  /          / |      z
-        # 0 ======== 1  |      |
-        # |          |  |      |   y
-        # |  7       |  6      |  /
-        # |          | /       | /
-        # |          |/        |/
-        # 4 ======== 5         -------> x
-        
-        # Check setup
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # Run over all halfedges
-        heCounter = 0
-
-        self.mesh.request_face_status()
-        self.mesh.request_vertex_status()
-        self.mesh.request_halfedge_status()
-        
-        # Get second edge
-        eh = self.mesh.edge_handle(2)
-        
-        # Delete one edge
-        self.mesh.delete_edge(eh)
-        
-        # Check setup ( No garbage collection, so nothing should change!)
-        self.assertEqual(self.mesh.n_edges(), 18)
-        self.assertEqual(self.mesh.n_halfedges(), 36)
-        self.assertEqual(self.mesh.n_vertices(), 8)
-        self.assertEqual(self.mesh.n_faces(), 12)
-        
-        # =====================================================
-        # Try to add low level edge with invalid incidents and
-        # check skipping iterator
-        # =====================================================
-        
-        # Add a low level edge without handles
-        eh_test = self.mesh.edge_handle(self.mesh.new_edge(openmesh.VertexHandle(), openmesh.VertexHandle()))
-        
-        count = 0
-        found_4  = False
-        found_5  = False
-        found_36 = False
-        found_37 = False
-        
-        for he in self.mesh.shalfedges():
-            if he.idx() == 4:
-                found_4 = True
-            if he.idx() == 5:
-                found_5 = True
-            if he.idx() == 36:
-                found_36 = True
-            if he.idx() == 37:
-                found_37 = True
-            count += 1
-            
-        self.assertEqual(count, 36)
-        self.assertFalse(found_4)
-        self.assertFalse(found_5)
-        self.assertTrue(found_36)
-        self.assertTrue(found_37)
-        
-        # =====================================================
-        # Try to delete one edge with invalid incidents and
-        # check skipping iterator
-        # =====================================================
-        
-        # Delete one edge and recheck (Halfedges 4 and 5)
-        self.mesh.delete_edge(eh_test)
-        
-        count = 0
-        found_4  = False
-        found_5  = False
-        found_36 = False
-        found_37 = False
-        
-        for he in self.mesh.shalfedges():
-            if he.idx() == 4:
-                found_4 = True
-            if he.idx() == 5:
-                found_5 = True
-            if he.idx() == 36:
-                found_36 = True
-            if he.idx() == 37:
-                found_37 = True
-            count += 1
-        
-        self.assertEqual(count, 34)
-        self.assertFalse(found_4)
-        self.assertFalse(found_5)
-        self.assertFalse(found_36)
-        self.assertFalse(found_37)
-        
-    def test_face_iter_empty_mesh_one_deleted_face(self):
-        # Request delete_face capability
-        self.mesh.request_vertex_status()
-        self.mesh.request_edge_status()
-        self.mesh.request_face_status()
-        
-        # Add some vertices
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        
-        # Add one face
-        fh = self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[0])
-        
-        is_delete_isolated_vertex = False
-        self.mesh.delete_face(fh, is_delete_isolated_vertex)
-        
-        # Test setup:
-        #  1 === 2
-        #  |   /
-        #  |  /
-        #  | /
-        #  0
-        
-        # Normal iterators
-        f_it = self.mesh.faces()
-        
-        self.assertEqual(f_it.__next__().idx(), 0)
-        self.assertRaises(StopIteration, f_it.__next__)
-        
-        # Same with skipping iterators
-        f_it = self.mesh.sfaces()
-        
-        self.assertRaises(StopIteration, f_it.__next__)
-        
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshIterators)
-    unittest.TextTestRunner(verbosity=2).run(suite)

src/Python/Unittests/test_trimesh_normal_calculations.py

@@ -1,103 +0,0 @@
-import unittest
-import openmesh
-
-class Normals(unittest.TestCase):
-    
-    def setUp(self):
-        self.mesh = openmesh.TriMesh()
-        
-        # Add some vertices
-        self.vhandle = []
-        
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
-        self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 1)))
-        
-        # Add four faces
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[2])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[0])
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[2])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[3])
-        self.mesh.add_face(face_vhandles)
-        
-        face_vhandles = []
-        
-        face_vhandles.append(self.vhandle[3])
-        face_vhandles.append(self.vhandle[1])
-        face_vhandles.append(self.vhandle[0])
-        self.mesh.add_face(face_vhandles)
-
-    def test_normal_calculations(self):
-        # Check one Request only vertex normals
-        # Face normals are required for vertex and halfedge normals, so
-        # that prevent access to non existing properties are in place
-    
-        self.mesh.request_vertex_normals()
-        self.mesh.request_halfedge_normals()
-
-        # Check blocks
-        self.mesh.update_normals()
-
-        # Request required face normals
-        self.mesh.request_face_normals()
-
-        # Automatically compute all normals
-        # As only vertex normals are requested and no face normals, this will compute nothing.
-        self.mesh.update_normals()
-
-        # Face normals alone
-        self.mesh.update_face_normals()
-
-        # Vertex normals alone (require valid face normals)
-        self.mesh.update_vertex_normals()
-
-        # Halfedge normals alone (require valid face normals)
-        self.mesh.update_halfedge_normals()
-
-    def test_calc_vertex_normal_fast(self):
-        self.mesh.request_vertex_normals()
-        self.mesh.request_halfedge_normals()
-        self.mesh.request_face_normals()
-
-        normal = openmesh.Vec3d()
-
-        self.mesh.calc_vertex_normal_fast(self.vhandle[2], normal)
-
-    def test_calc_vertex_normal_correct(self):
-        self.mesh.request_vertex_normals()
-        self.mesh.request_halfedge_normals()
-        self.mesh.request_face_normals()
-        
-        normal = openmesh.Vec3d()
-        
-        self.mesh.calc_vertex_normal_correct(self.vhandle[2], normal)
-
-    def test_calc_vertex_normal_loop(self):
-        self.mesh.request_vertex_normals()
-        self.mesh.request_halfedge_normals()
-        self.mesh.request_face_normals()
-        
-        normal = openmesh.Vec3d()
-        
-        self.mesh.calc_vertex_normal_loop(self.vhandle[2], normal)
-
-
-if __name__ == '__main__':
-    suite = unittest.TestLoader().loadTestsFromTestCase(Normals)
-    unittest.TextTestRunner(verbosity=2).run(suite)