Merge branch 'master' into ply_handle_extra_elements

.gitlab-ci.yml

@@ -8,13 +8,13 @@ clang-c++11:
   tags:
     - Linux
 
-gcc-c++98:
-  script: "CI/ci-linux.sh gcc C++98"
+gcc-c++14:
+  script: "CI/ci-linux.sh gcc C++14"
   tags:
     - Linux
 
-clang-c++98:
-  script: "CI/ci-linux.sh clang C++98"
+clang-c++14:
+  script: "CI/ci-linux.sh clang C++14"
   tags: 
     - Linux
 
@@ -28,13 +28,13 @@ macos-c++11:
       - build-release-cpp11/*.tar.gz
 
 macos-c++98:
-  script: "CI/ci-mac.sh C++98"
+  script: "CI/ci-mac.sh C++14"
   tags:
     - Apple
   artifacts:
     paths:
-      - build-release-cpp98/*.dmg
-      - build-release-cpp98/*.tar.gz
+      - build-release-cpp14/*.dmg
+      - build-release-cpp14/*.tar.gz
 
 cppcheck:
   script: "CI/ci-cppcheck.sh"

CI/ci-cppcheck.sh

@@ -38,9 +38,11 @@ echo "CPPCHECK Summary"
 echo "=============================================================================="
 echo -e "${NC}"
 
-if [ $COUNT -gt 0 ]; then
+MAX_COUNT=6
+
+if [ $COUNT -gt $MAX_COUNT ]; then
   echo -e ${WARNING}
-  echo "Total CPPCHECK error Count is $COUNT, which is too High! CPPCHECK Run failed";
+  echo "Total CPPCHECK error Count is $COUNT, which is too High (max is $MAX_COUNT)! CPPCHECK Run failed";
   echo -e "${NC}"
   exit 1;
 else

CI/ci-linux.sh

@@ -33,6 +33,10 @@ elif [ "$LANGUAGE" == "C++11" ]; then
   echo "Building with C++11";
   OPTIONS="$OPTIONS -DCMAKE_CXX_FLAGS='-std=c++11' "
   BUILDPATH="$BUILDPATH-cpp11"  
+elif [ "$LANGUAGE" == "C++14" ]; then
+  echo "Building with C++14";
+  OPTIONS="$OPTIONS -DCMAKE_CXX_FLAGS='-std=c++14' "
+  BUILDPATH="$BUILDPATH-cpp14"  
 fi  
 
 #=====================================

CI/ci-mac.sh

@@ -18,6 +18,10 @@ elif [ "$LANGUAGE" == "C++11" ]; then
   echo "Building with C++11";
   OPTIONS="$OPTIONS -DCMAKE_CXX_FLAGS='-std=c++11' "
   BUILDPATH="cpp11"  
+elif [ "$LANGUAGE" == "C++14" ]; then
+  echo "Building with C++14";
+  OPTIONS="$OPTIONS -DCMAKE_CXX_FLAGS='-std=c++14' "
+  BUILDPATH="cpp14"
 fi  
 
 #=====================================

Doc/changelog.docu

@@ -8,6 +8,11 @@
 
 <tr valign=top><td><b>7.0</b> (?/?/?)</td><td>
 
+<b>Breaking changes</b>
+<ul>
+<li>The minimal standard for C++ has been raised to C++11. Compilers not supporting C++11 or higher are no longer supported</li>
+</ul>
+
 <b>Core</b>
 <ul>
 <li>Implemented a cast from polyMesh to Mesh and vice versa using static_cast(polymeshInstance) or static_cast(trimeshInstance)</li>
@@ -43,6 +48,11 @@
 <li>Added unittest to write and read faceTexcoords with a test obj file</li>
 </ul>
 
+<b>Python</b>
+<ul>
+<li>fix the stripping of the python libs version string</li>
+</ul>
+
 <b>General</b>
 <ul>
 <li>Updated Logo</li>

cmake/FindGoogleTest.cmake

@@ -42,6 +42,7 @@ else(GTEST_INCLUDE_DIRS AND GTEST_LIBRARIES AND GTEST_MAIN_LIBRARIES)
   else(GTEST_PREFIX)
     find_path(_GTEST_INCLUDE_DIR "gtest/gtest.h"
       PATHS
+      ~/sw/gtest-1.8.0/include
       ~/sw/gtest-1.7.0/include
       ~/sw/gtest/include     
       /ACG/acgdev/gcc-4.7-x86_64/gtest/include
@@ -52,6 +53,7 @@ else(GTEST_INCLUDE_DIRS AND GTEST_LIBRARIES AND GTEST_MAIN_LIBRARIES)
       NO_DEFAULT_PATH )
     find_library(_GTEST_LIBRARY gtest
       PATHS
+      ~/sw/gtest-1.8.0/lib
       ~/sw/gtest-1.7.0/lib
       ~/sw/gtest/lib
       /ACG/acgdev/gcc-4.7-x86_64/gtest/lib
@@ -62,6 +64,7 @@ else(GTEST_INCLUDE_DIRS AND GTEST_LIBRARIES AND GTEST_MAIN_LIBRARIES)
       NO_DEFAULT_PATH )
     find_library(_GTEST_MAIN_LIBRARY gtest_main
       PATHS
+      ~/sw/gtest-1.8.0/lib
       ~/sw/gtest-1.7.0/lib
       ~/sw/gtest/lib
       /ACG/acgdev/gcc-4.7-x86_64/gtest/lib

src/OpenMesh/Apps/Unsupported/IvViewer/SoOpenMeshNodeT.hh

@@ -85,7 +85,7 @@ class SoOpenMeshNodeT : public SoShape
 public:
 
   static void initClass();
-  SoOpenMeshNodeT(const Mesh* _mesh=0);
+  explicit SoOpenMeshNodeT(const Mesh* _mesh=0);
   void setMesh(const Mesh* mesh) { d_mesh = mesh; }
 
 

src/OpenMesh/Core/System/mostream.hh

@@ -96,7 +96,7 @@ template <class T>
 class multiplex_target : public basic_multiplex_target
 {
 public:
-  multiplex_target(T& _t) : target_(_t) {}
+  explicit multiplex_target(T& _t) : target_(_t) {}
   virtual void operator<<(const std::string& _s) { target_ << _s; }
 private:
   T& target_;

src/OpenMesh/Core/Utils/RandomNumberGenerator.hh

@@ -90,7 +90,7 @@ public:
   *
   * @param _resolution specifies the desired resolution for the random number generated
   */
-  RandomNumberGenerator(const size_t _resolution);
+  explicit RandomNumberGenerator(const size_t _resolution);
 
   /// returns a random double between 0.0 and 1.0 with a guaranteed resolution
   double getRand() const;

src/OpenMesh/Tools/Decimater/Observer.hh

@@ -87,7 +87,7 @@ public:
    *
    * @param _notificationInterval Interval of decimation steps between notifications.
    */
-  Observer(size_t _notificationInterval);
+  explicit Observer(size_t _notificationInterval);
   
   /// Destructor
   virtual ~Observer();

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

@@ -115,7 +115,7 @@ public:
   CatmullClarkT(  ) : parent_t() {  }
 
   /// Constructor
-  CatmullClarkT(MeshType &_m) : parent_t(_m) {  }
+  explicit CatmullClarkT(MeshType &_m) : parent_t(_m) {  }
 
   virtual ~CatmullClarkT() {}
 

src/OpenMesh/Tools/Subdivider/Uniform/Composite/CompositeT.hh

@@ -37,215 +37,215 @@
  * 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$                   *
- *                                                                           *
-\*===========================================================================*/
-
-/** \file Uniform/Composite/CompositeT.hh
-    
- */
-
-//=============================================================================
-//
-//  CLASS CompositeT
-//
-//=============================================================================
-
-#ifndef OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_HH
-#define OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_HH
-
-
-//== INCLUDES =================================================================
-
-#include <string>
-#include <vector>
-// --------------------
-#include <OpenMesh/Tools/Subdivider/Uniform/SubdividerT.hh>
-
-//== NAMESPACE ================================================================
-
-namespace OpenMesh   { // BEGIN_NS_OPENMESH
-namespace Subdivider { // BEGIN_NS_DECIMATER
-namespace Uniform    { // BEGIN_NS_UNIFORM
-
-
-//== CLASS DEFINITION =========================================================
-
-/** This class provides the composite subdivision rules for the uniform case.
- *
- *  To create a subdivider derive from this class and overload the functions
- *  name() and apply_rules(). In the latter one call the wanted rules.
- *
- *  For details on the composite scheme refer to
- *  - <a
- *  href="http://cm.bell-labs.com/who/poswald/sqrt3.pdf">P. Oswald,
- *  P. Schroeder "Composite primal/dual sqrt(3)-subdivision schemes",
- *  CAGD 20, 3, 2003, 135--164</a>
-
- *  \note Not all rules are implemented!
- *  \see class Adaptive::CompositeT
- */
-template <typename MeshType, typename RealType=float > 
-class CompositeT : public SubdividerT< MeshType, RealType >
-{
-public:
-
-  typedef RealType                                real_t;
-  typedef MeshType                                mesh_t;
-  typedef SubdividerT< mesh_t, real_t >           parent_t;
-
-public:
-
-  CompositeT(void) : parent_t(), p_mesh_(NULL) {}
-  CompositeT(MeshType& _mesh) : parent_t(_mesh), p_mesh_(NULL) {};
-  virtual ~CompositeT() { }
-
-public: // inherited interface
-
-  virtual const char *name( void ) const = 0;
-
-protected: // inherited interface
-
-  bool prepare( MeshType& _m );
-
-  bool subdivide( MeshType& _m, size_t _n, const bool _update_points = true  )
-  {
-    assert( p_mesh_ == &_m );
-
-    while(_n--)
-    {
-      apply_rules();
-      commit(_m);
-    }
-   
-    return true;
-  }
-
-#ifdef NDEBUG
-  bool cleanup( MeshType& ) 
-#else
-  bool cleanup( MeshType& _m ) 
-#endif
-  { 
-    assert( p_mesh_ == &_m );
-    p_mesh_=NULL; 
-    return true; 
-  }
-
-protected:
-
-  /// Assemble here the rule sequence, by calling the constructor
-  /// of the wanted rules.
-  virtual void apply_rules(void) = 0;
-
-protected:
-
-  /// Move vertices to new positions after the rules have been applied
-  /// to the mesh (called by subdivide()).
-  void commit( MeshType &_m)
-  {
-    typename MeshType::VertexIter v_it;
-
-    for (v_it=_m.vertices_begin(); v_it != _m.vertices_end(); ++v_it)
-      _m.set_point(*v_it, _m.data(*v_it).position());
-  }
-
-  
-public:
-
-  /// Abstract base class for coefficient functions
-  struct Coeff
-  {
-    virtual ~Coeff() { }
-    virtual double operator() (size_t _valence) = 0;
-  };
-
-
-protected:
-
-  typedef typename MeshType::Scalar         scalar_t;
-  typedef typename MeshType::VertexHandle   VertexHandle;
-  typedef typename MeshType::FaceHandle     FaceHandle;
-  typedef typename MeshType::EdgeHandle     EdgeHandle;
-  typedef typename MeshType::HalfedgeHandle HalfedgeHandle;
-
-  /// \name Uniform composite subdivision rules
-  //@{
-
-  
-  void Tvv3(); ///< Split Face, using Vertex information (1-3 split)
-  void Tvv4(); ///< Split Face, using Vertex information (1-4 split)
-  void Tfv();  ///< Split Face, using Face Information
-
-  void FF();                 ///< Face to face averaging.
-  void FFc(Coeff& _coeff);   ///< Weighted face to face averaging.
-  void FFc(scalar_t _c);     ///< Weighted face to face averaging.
-
-  void FV();                 ///< Face to vertex averaging.
-  void FVc(Coeff& _coeff);   ///< Weighted face to vertex Averaging with flaps 
-  void FVc(scalar_t _c);     ///< Weighted face to vertex Averaging with flaps 
-
-  void FE();                 ///< Face to edge averaging.
-
-  void VF();                 ///< Vertex to Face Averaging.
-  void VFa(Coeff& _coeff);   ///< Vertex to Face Averaging, weighted.
-  void VFa(scalar_t _alpha); ///< Vertex to Face Averaging, weighted.
-
-  void VV();                  ///< Vertex to vertex averaging.
-  void VVc(Coeff& _coeff);    ///< Vertex to vertex averaging, weighted.
-  void VVc(scalar_t _c);      ///< Vertex to vertex averaging, weighted.
-
-  void VE();                  ///< VE Step (Vertex to Edge Averaging)
-
-  
-  void VdE();             ///< Vertex to edge averaging, using diamond of edges.
-  void VdEc(scalar_t _c); ///< Weighted vertex to edge averaging, using diamond of edges
-  
-  /// Weigthed vertex to edge averaging, using diamond of edges for
-  /// irregular vertices.
-  void VdEg(Coeff& _coeff);
-  /// Weigthed vertex to edge averaging, using diamond of edges for
-  /// irregular vertices.
-  void VdEg(scalar_t _gamma);
-
-  void EF();               ///< Edge to face averaging.
-  
-  void EV();               ///< Edge to vertex averaging.
-  void EVc(Coeff& _coeff); ///< Weighted edge to vertex averaging.
-  void EVc(scalar_t _c);   ///< Weighted edge to vertex averaging.
-
-  void EdE();              ///< Edge to edge averaging w/ flap rule.
-  void EdEc(scalar_t _c);  ///< Weighted edge to edge averaging w/ flap rule.
-
-
-  //@}
-
-  void corner_cutting(HalfedgeHandle _heh);
-
-  VertexHandle split_edge(HalfedgeHandle _heh);
-
-private:
-
-  MeshType* p_mesh_;
-
-};
-
-
-//=============================================================================
-} // END_NS_UNIFORM
-} // END_NS_SUBDIVIDER
-} // END_NS_OPENMESH
-//=============================================================================
-#if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC)
-#define OPENMESH_SUBDIVIDER_TEMPLATES
-#include "CompositeT.cc"
-#endif
-//=============================================================================
-#endif // COMPOSITET_HH defined
-//=============================================================================
-
+ * ========================================================================= */
+
+/*===========================================================================*\
+ *                                                                           *             
+ *   $Revision$                                                         *
+ *   $Date$                   *
+ *                                                                           *
+\*===========================================================================*/
+
+/** \file Uniform/Composite/CompositeT.hh
+    
+ */
+
+//=============================================================================
+//
+//  CLASS CompositeT
+//
+//=============================================================================
+
+#ifndef OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_HH
+#define OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_HH
+
+
+//== INCLUDES =================================================================
+
+#include <string>
+#include <vector>
+// --------------------
+#include <OpenMesh/Tools/Subdivider/Uniform/SubdividerT.hh>
+
+//== NAMESPACE ================================================================
+
+namespace OpenMesh   { // BEGIN_NS_OPENMESH
+namespace Subdivider { // BEGIN_NS_DECIMATER
+namespace Uniform    { // BEGIN_NS_UNIFORM
+
+
+//== CLASS DEFINITION =========================================================
+
+/** This class provides the composite subdivision rules for the uniform case.
+ *
+ *  To create a subdivider derive from this class and overload the functions
+ *  name() and apply_rules(). In the latter one call the wanted rules.
+ *
+ *  For details on the composite scheme refer to
+ *  - <a
+ *  href="http://cm.bell-labs.com/who/poswald/sqrt3.pdf">P. Oswald,
+ *  P. Schroeder "Composite primal/dual sqrt(3)-subdivision schemes",
+ *  CAGD 20, 3, 2003, 135--164</a>
+
+ *  \note Not all rules are implemented!
+ *  \see class Adaptive::CompositeT
+ */
+template <typename MeshType, typename RealType=float > 
+class CompositeT : public SubdividerT< MeshType, RealType >
+{
+public:
+
+  typedef RealType                                real_t;
+  typedef MeshType                                mesh_t;
+  typedef SubdividerT< mesh_t, real_t >           parent_t;
+
+public:
+
+  CompositeT(void) : parent_t(), p_mesh_(NULL) {}
+  explicit CompositeT(MeshType& _mesh) : parent_t(_mesh), p_mesh_(NULL) {};
+  virtual ~CompositeT() { }
+
+public: // inherited interface
+
+  virtual const char *name( void ) const = 0;
+
+protected: // inherited interface
+
+  bool prepare( MeshType& _m );
+
+  bool subdivide( MeshType& _m, size_t _n, const bool _update_points = true  )
+  {
+    assert( p_mesh_ == &_m );
+
+    while(_n--)
+    {
+      apply_rules();
+      commit(_m);
+    }
+   
+    return true;
+  }
+
+#ifdef NDEBUG
+  bool cleanup( MeshType& ) 
+#else
+  bool cleanup( MeshType& _m ) 
+#endif
+  { 
+    assert( p_mesh_ == &_m );
+    p_mesh_=NULL; 
+    return true; 
+  }
+
+protected:
+
+  /// Assemble here the rule sequence, by calling the constructor
+  /// of the wanted rules.
+  virtual void apply_rules(void) = 0;
+
+protected:
+
+  /// Move vertices to new positions after the rules have been applied
+  /// to the mesh (called by subdivide()).
+  void commit( MeshType &_m)
+  {
+    typename MeshType::VertexIter v_it;
+
+    for (v_it=_m.vertices_begin(); v_it != _m.vertices_end(); ++v_it)
+      _m.set_point(*v_it, _m.data(*v_it).position());
+  }
+
+  
+public:
+
+  /// Abstract base class for coefficient functions
+  struct Coeff
+  {
+    virtual ~Coeff() { }
+    virtual double operator() (size_t _valence) = 0;
+  };
+
+
+protected:
+
+  typedef typename MeshType::Scalar         scalar_t;
+  typedef typename MeshType::VertexHandle   VertexHandle;
+  typedef typename MeshType::FaceHandle     FaceHandle;
+  typedef typename MeshType::EdgeHandle     EdgeHandle;
+  typedef typename MeshType::HalfedgeHandle HalfedgeHandle;
+
+  /// \name Uniform composite subdivision rules
+  //@{
+
+  
+  void Tvv3(); ///< Split Face, using Vertex information (1-3 split)
+  void Tvv4(); ///< Split Face, using Vertex information (1-4 split)
+  void Tfv();  ///< Split Face, using Face Information
+
+  void FF();                 ///< Face to face averaging.
+  void FFc(Coeff& _coeff);   ///< Weighted face to face averaging.
+  void FFc(scalar_t _c);     ///< Weighted face to face averaging.
+
+  void FV();                 ///< Face to vertex averaging.
+  void FVc(Coeff& _coeff);   ///< Weighted face to vertex Averaging with flaps 
+  void FVc(scalar_t _c);     ///< Weighted face to vertex Averaging with flaps 
+
+  void FE();                 ///< Face to edge averaging.
+
+  void VF();                 ///< Vertex to Face Averaging.
+  void VFa(Coeff& _coeff);   ///< Vertex to Face Averaging, weighted.
+  void VFa(scalar_t _alpha); ///< Vertex to Face Averaging, weighted.
+
+  void VV();                  ///< Vertex to vertex averaging.
+  void VVc(Coeff& _coeff);    ///< Vertex to vertex averaging, weighted.
+  void VVc(scalar_t _c);      ///< Vertex to vertex averaging, weighted.
+
+  void VE();                  ///< VE Step (Vertex to Edge Averaging)
+
+  
+  void VdE();             ///< Vertex to edge averaging, using diamond of edges.
+  void VdEc(scalar_t _c); ///< Weighted vertex to edge averaging, using diamond of edges
+  
+  /// Weigthed vertex to edge averaging, using diamond of edges for
+  /// irregular vertices.
+  void VdEg(Coeff& _coeff);
+  /// Weigthed vertex to edge averaging, using diamond of edges for
+  /// irregular vertices.
+  void VdEg(scalar_t _gamma);
+
+  void EF();               ///< Edge to face averaging.
+  
+  void EV();               ///< Edge to vertex averaging.
+  void EVc(Coeff& _coeff); ///< Weighted edge to vertex averaging.
+  void EVc(scalar_t _c);   ///< Weighted edge to vertex averaging.
+
+  void EdE();              ///< Edge to edge averaging w/ flap rule.
+  void EdEc(scalar_t _c);  ///< Weighted edge to edge averaging w/ flap rule.
+
+
+  //@}
+
+  void corner_cutting(HalfedgeHandle _heh);
+
+  VertexHandle split_edge(HalfedgeHandle _heh);
+
+private:
+
+  MeshType* p_mesh_;
+
+};
+
+
+//=============================================================================
+} // END_NS_UNIFORM
+} // END_NS_SUBDIVIDER
+} // END_NS_OPENMESH
+//=============================================================================
+#if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC)
+#define OPENMESH_SUBDIVIDER_TEMPLATES
+#include "CompositeT.cc"