MeshKernel.hh

/* ========================================================================= *
 *                                                                           *
 *                               OpenMesh                                    *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openmesh.org                               *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenMesh.                                            *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * 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$                   *
 *                                                                           *
\*===========================================================================*/


//=============================================================================
//
//  Kernel Concept
//
//=============================================================================


#error this file is for documentation purposes only


//== NAMESPACES ===============================================================


namespace OpenMesh {
namespace Concepts {


//== CLASS DEFINITION =========================================================


template <class FinalMeshItems> class KernelT
{
public:



  typedef typename FinalMeshItems::Vertex             Vertex;
  typedef typename FinalMeshItems::Halfedge           Halfedge;
  typedef typename FinalMeshItems::Edge               Edge;
  typedef typename FinalMeshItems::Face               Face;
  typedef typename FinalMeshItems::Point              Point;
  typedef typename FinalMeshItems::Scalar             Scalar;
  typedef typename FinalMeshItems::Normal             Normal;
  typedef typename FinalMeshItems::Color              Color;
  typedef typename FinalMeshItems::TexCoord           TexCoord;
  typedef typename FinalMeshItems::VertexHandle       VertexHandle;
  typedef typename FinalMeshItems::HalfedgeHandle     HalfedgeHandle;
  typedef typename FinalMeshItems::EdgeHandle         EdgeHandle;
  typedef typename FinalMeshItems::FaceHandle         FaceHandle;




  typedef SomeIterator KernelVertexIter;
  typedef SomeIterator KernelConstVertexIter;
  typedef SomeIterator KernelEdgeIter;
  typedef SomeIterator KernelConstEdgeIter;
  typedef SomeIterator KernelFaceIter;
  typedef SomeIterator KernelConstFaceIter;


  KernelT() {}

  ~KernelT();

  KernelT& operator=(const KernelT& _rhs);


  void reserve( unsigned int _n_vertices,
                unsigned int _n_edges,
                unsigned int _n_faces );



  const Vertex& vertex(VertexHandle _h) const { return deref(_h); }
  Vertex& vertex(VertexHandle _h) { return deref(_h); }
  const Halfedge& halfedge(HalfedgeHandle _h) const { return deref(_h); }
  Halfedge& halfedge(HalfedgeHandle _h) { return deref(_h); }
  const Edge& edge(EdgeHandle _h) const { return deref(_h); }
  Edge& edge(EdgeHandle _h) { return deref(_h); }
  const Face& face(FaceHandle _h) const { return deref(_h); }
  Face& face(FaceHandle _h) { return deref(_h); }



  VertexHandle handle(const Vertex& _v) const;
  HalfedgeHandle handle(const Halfedge& _he) const;
  EdgeHandle handle(const Edge& _e) const;
  FaceHandle handle(const Face& _f) const;



  VertexHandle   vertex_handle(unsigned int _i) const;
  HalfedgeHandle halfedge_handle(unsigned int _i) const;
  EdgeHandle     edge_handle(unsigned int _i) const;
  FaceHandle     face_handle(unsigned int _i) const;




  void clear();

  void clean();

  void garbage_collection();

  void remove_last_vertex() { vertices_.pop_back(); }
  void remove_last_edge()   { edges_.pop_back();    }
  void remove_last_face()   { faces_.pop_back();    }






  unsigned int n_vertices() const;
  unsigned int n_halfedges() const;
  unsigned int n_edges() const;
  unsigned int n_faces() const;
  bool vertices_empty() const;
  bool halfedges_empty() const;
  bool edges_empty() const;
  bool faces_empty() const;




  HalfedgeHandle halfedge_handle(VertexHandle _vh) const;
  void set_halfedge_handle(VertexHandle _vh, HalfedgeHandle _heh);
  const Point& point(VertexHandle _vh) const;
  const Point& point(const Vertex& _v) const;
  void set_point(VertexHandle _vh, const Point& _p);
  void set_point(Vertex& _v, const Point& _p);





  VertexHandle to_vertex_handle(HalfedgeHandle _heh) const;
  VertexHandle from_vertex_handle(HalfedgeHandle _heh) const;
  void set_vertex_handle(HalfedgeHandle _heh, VertexHandle _vh);
  FaceHandle face_handle(HalfedgeHandle _heh) const;
  void set_face_handle(HalfedgeHandle _heh, FaceHandle _fh);
  HalfedgeHandle next_halfedge_handle(HalfedgeHandle _heh) const;
  void set_next_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _nheh);
  HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh) const;
  HalfedgeHandle opposite_halfedge_handle(HalfedgeHandle _heh) const;
  HalfedgeHandle ccw_rotated_halfedge_handle(HalfedgeHandle _heh) const;
  HalfedgeHandle cw_rotated_halfedge_handle(HalfedgeHandle _heh) const;
  EdgeHandle edge_handle(HalfedgeHandle _heh) const;




  HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i) const;




  HalfedgeHandle halfedge_handle(FaceHandle _fh) const;
  void set_halfedge_handle(FaceHandle _fh, HalfedgeHandle _heh);


public: // Standard Property Management



  // vertex
  const Point& point(VertexHandle _vh) const; 
  void set_point(VertexHandle _vh, const Point& _p); 
  Point& point(VertexHandle _vh); 

  const Normal& normal(VertexHandle _vh) const; 
  void set_normal(VertexHandle _vh, const Normal& _n); 

  const Normal& normal(HalfedgeHandle _heh) const; 
  void set_normal(HalfedgeHandle _heh, const Normal& _n); 

  const Color& color(VertexHandle _vh) const; 
  void set_color(VertexHandle _vh, const Color& _c); 

  const TexCoord1D& texcoord1D(VertexHandle _vh) const; 
  void set_texcoord1D(VertexHandle _vh, const TexCoord1D& _t); 

  const TexCoord2D& texcoord2D(VertexHandle _vh) const; 
  void set_texcoord2D(VertexHandle _vh, const TexCoord2D& _t); 

  const TexCoord3D& texcoord3D(VertexHandle _vh) const; 
  void set_texcoord3D(VertexHandle _vh, const TexCoord3D& _t); 

  const TexCoord1D& texcoord1D(HalfedgeHandle _hh) const; 
  void set_texcoord1D(HalfedgeHandle _hh, const TexCoord1D& _t); 

  const TexCoord2D& texcoord2D(HalfedgeHandle _hh) const; 
  void set_texcoord2D(HalfedgeHandle _hh, const TexCoord2D& _t); 

  const TexCoord3D& texcoord3D(HalfedgeHandle _hh) const; 
  void set_texcoord3D(HalfedgeHandle _hh, const TexCoord3D& _t); 

  const StatusInfo& status(VertexHandle _vh) const; 
  StatusInfo& status(VertexHandle _vh); 

  // halfedge
  const StatusInfo& status(HalfedgeHandle _vh) const; 
  StatusInfo& status(HalfedgeHandle _vh); 

  const Color& color(HalfedgeHandle _heh) const; 
  void set_color(HalfedgeHandle _heh, const Color& _c); 

  // edge
  const Color& color(EdgeHandle _eh) const; 
  void set_color(EdgeHandle _eh, const Color& _c); 


  const StatusInfo& status(EdgeHandle _vh) const; 
  StatusInfo& status(EdgeHandle _vh); 

  // face
  const Normal& normal(FaceHandle _fh) const; 
  void set_normal(FaceHandle _fh, const Normal& _n); 

  const Color& color(FaceHandle _fh) const; 
  void set_color(FaceHandle _fh, const Color& _c); 

  const StatusInfo& status(FaceHandle _vh) const; 
  StatusInfo& status(FaceHandle _vh); 



  void request_vertex_normals();
  void request_vertex_colors();
  void request_vertex_texcoords1D();
  void request_vertex_texcoords2D();
  void request_vertex_texcoords3D();
  void request_vertex_status();

  void request_halfedge_status();
  void request_halfedge_normals();
  void request_halfedge_colors();
  void request_halfedge_texcoords1D();
  void request_halfedge_texcoords2D();
  void request_halfedge_texcoords3D();

  void request_edge_status();
  void request_edge_colors();

  void request_face_normals();
  void request_face_colors();
  void request_face_status();
  void request_face_texture_index();


  void release_vertex_normals();
  void release_vertex_colors();
  void release_vertex_texcoords1D();
  void release_vertex_texcoords2D();
  void release_vertex_texcoords3D();
  void release_vertex_status();

  void release_halfedge_status();
  void release_halfedge_normals();
  void release_halfedge_colors();
  void release_halfedge_texcoords1D();
  void release_halfedge_texcoords2D();
  void release_halfedge_texcoords3D();

  void release_edge_status();
  void release_edge_colors();

  void release_face_normals();
  void release_face_colors();
  void release_face_status();
  void release_face_texture_index();


  bool has_vertex_normals()     const;
  bool has_vertex_colors()      const;
  bool has_vertex_texcoords1D() const;
  bool has_vertex_texcoords2D() const;
  bool has_vertex_texcoords3D() const;
  bool has_vertex_status()      const;

  bool has_halfedge_status()      const;
  bool has_halfedge_normals()     const;
  bool has_halfedge_colors()      const;
  bool has_halfedge_texcoords1D() const;
  bool has_halfedge_texcoords2D() const;
  bool has_halfedge_texcoords3D() const;

  bool has_edge_status() const;
  bool has_edge_colors() const;

  bool has_face_normals() const;
  bool has_face_colors() const;
  bool has_face_status() const;
  bool has_face_texture_index() const;

public: // Property Management



  template <typename T> void add_property( [VEHFM]PropHandleT<T>& _ph,
                                           const std::string& _name = "" );


  template <typename T> void remove_property( [VEHFM]PropHandleT<T>& );


  template <typename T>
  bool get_property_handle( [VEHFM]PropHandleT<T>& ph, const std::string& _n ) const;


  template <typename T> PropertyT<T>& property( [VEHF]PropHandleT<T> _ph );
  template <typename T> const PropertyT<T>& property( [VEHF]PropHandleT<T> _ph ) const;
  template <typename T> PropertyT<T>& mproperty( MPropHandleT<T> _ph );
  template <typename T> const PropertyT<T>& mproperty( MPropHandleT<T> _ph ) const;



  template <typename T>
  T& property( VPropHandleT<T> _ph, VertexHandle _vh );
  template <typename T>
  const T& property( VPropHandleT<T> _ph, VertexHandle _vh ) const;

  template <typename T>
  T& property( EPropHandleT<T> _ph, EdgeHandle _vh );
  template <typename T>
  const T& property( EPropHandleT<T> _ph, EdgeHandle _vh ) const;

  template <typename T>
  T& property( HPropHandleT<T> _ph, HalfedgeHandle _vh );
  template <typename T>
  const T& property( HPropHandleT<T> _ph, HalfedgeHandle _vh ) const;

  template <typename T>
  T& property( FPropHandleT<T> _ph, FaceHandle _vh );
  template <typename T>
  const T& property( FPropHandleT<T> _ph, FaceHandle _vh ) const;

  template <typename T>
  T& property( MPropHandleT<T> _ph );
  template <typename T>
  const T& property( MPropHandleT<T> _ph ) const;


public:




  VertexHandle new_vertex();
  VertexHandle new_vertex(const Point& _p);
  VertexHandle new_vertex(const Vertex& _v);
  HalfedgeHandle new_edge(VertexHandle _start_vertex_handle,
                          VertexHandle _end_vertex_handle);

  FaceHandle new_face();
  FaceHandle new_face(const Face& _f);


  // --- iterators ---



  KernelVertexIter vertices_begin();
  KernelConstVertexIter vertices_begin() const;
  KernelVertexIter vertices_end();
  KernelConstVertexIter vertices_end() const;
  KernelEdgeIter edges_begin();
  KernelConstEdgeIter edges_begin() const;
  KernelEdgeIter edges_end();
  KernelConstEdgeIter edges_end() const;
  KernelFaceIter faces_begin();
  KernelConstFaceIter faces_begin() const;
  KernelFaceIter faces_end();
  KernelConstFaceIter faces_end() const;



private:


  // --- private functions ---

  KernelT(const KernelT& _rhs);
};
};


//=============================================================================
} // namespace Concepts
} // namespace OpenMesh
//=============================================================================