/*===========================================================================*\
 *                                                                           *
 *                               OpenMesh                                    *
 *      Copyright (C) 2001-2014 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openmesh.org                                *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenMesh.                                           *
 *                                                                           *
 *  OpenMesh is free software: you can redistribute it and/or modify         *
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenMesh is distributed in the hope that it will be useful,              *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *  GNU Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenMesh.  If not,                                    *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision: 990 $                                                         *
 *   $Date: 2014-02-05 10:01:07 +0100 (Mi, 05. Feb 2014) $                   *
 *                                                                           *
\*===========================================================================*/


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


#error this file is for documentation purposes only


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


namespace OpenMesh {
namespace Concepts {


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


/** \ingroup mesh_concepts_group
    This class describes the minimum interface a mesh kernel
    has to implement (because the resulting mesh will rely on
    this interface).

    This is the template class the actually holds the mesh kernel
    implementation. All functions marked as internal should only be used
    by the mesh class (that inherits the kernel). The mesh may then
    provide wrapper functions that provide the same functionality.

    \todo Check, if the member list is complete.
*/
template <class FinalMeshItems> class KernelT
{
public:

  /// \name Mesh Items
  //@{

  /// Derive this type from the FinalMeshItems
  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;

  //@}


  /// \name Kernel Iterators
  //@{
  /// This type depends on the container type in use.
  typedef SomeIterator KernelVertexIter;
  typedef SomeIterator KernelConstVertexIter;
  typedef SomeIterator KernelEdgeIter;
  typedef SomeIterator KernelConstEdgeIter;
  typedef SomeIterator KernelFaceIter;
  typedef SomeIterator KernelConstFaceIter;
  //@}

  /// \name Constructor/Destructor
  //@{
  /// Default constructor
  KernelT() {}

  /// Destructor
  ~KernelT();
  //@}

  /// Assignment operator
  KernelT& operator=(const KernelT& _rhs);


  /** Reserve memory for vertices, edges, faces.
   *
   *  Reserve memory for the mesh items vertices, edges, faces.  Use
   *  this method if you can estimate the memory consumption, for
   *  instance in algorithm expanding the mesh. Depending on the
   *  underlying array type you might be better of using this method,
   *  then letting the array type decide when to increase the
   *  capacity. For instance the STL vector class \c std::vector (used
   *  in the supplied ArrayKernelT) doubles the capacity if it is
   *  exhausted. This might lead to an memory allocation exception,
   *  though an smaller increment would be enough.
   */
  void reserve( unsigned int _n_vertices,
		unsigned int _n_edges,
		unsigned int _n_faces );


  /// \name Handle -> Item.
  //@{
  /// Translate handle to item (see also OpenMesh::PolyMeshT::deref())
  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); }
  //@}


  /// \name Item -> Handle
  //@{
  /// Translate item to handle
  VertexHandle handle(const Vertex& _v) const;
  HalfedgeHandle handle(const Halfedge& _he) const;
  EdgeHandle handle(const Edge& _e) const;
  FaceHandle handle(const Face& _f) const;
  //@}


  /// \name Get the i'th item
  //@{
  /// Get the i'th item
  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;
  //@}


  /// \name Delete items
  //@{
  /**  Delete all items, i.e. clear all item containers.
   *   The properties will also be removed from the mesh
   */
  void clear();

  /**  Delete all items, i.e. clear all item containers.
   *   The properties will be kept
   */
  void clean();

  /** Remove all items that are marked as deleted from the
      corresponding containers.
      \note All handles (and indices) to any entity (face, vertex,
            edge, halfedge) created before garbage collection
            will be out of sync with the mesh, do not use them anymore!
            See also \ref deletedElements.
      \note Needs the Attributes::Status attribute
      \note This function may not be implemented for all kernels.
  */
  void garbage_collection();

  /** Remove the last vertex imidiately, i.e. call pop_back() for the
      VertexContainer.
  */
  void remove_last_vertex() { vertices_.pop_back(); }
  /** Remove the last edge imidiately, i.e. call pop_back() for the
      EdgeContainer. Used e.g. by the add_face() method of PolyMeshT
  */
  void remove_last_edge()   { edges_.pop_back();    }
  /** Remove the last face imidiately, i.e. call pop_back() for the
      FaceContainer. Used e.g. by the add_face() method of PolyMeshT
  */
  void remove_last_face()   { faces_.pop_back();    }

  //@}




  /// \name Number of elements
  //@{
  /// Returns number of vertices
  unsigned int n_vertices() const;
  /// Returns number of halfedges (should be 2*n_edges())
  unsigned int n_halfedges() const;
  /// Returns number of edges
  unsigned int n_edges() const;
  /// Returns number of faces
  unsigned int n_faces() const;
  /// Is the vertex container empty?
  bool vertices_empty() const;
  /// Is the halfedge container empty (should be the same as edges_empty()).
  bool halfedges_empty() const;
  /// Is the edge container empty?
  bool edges_empty() const;
  /// Is the face container empty?
  bool faces_empty() const;
  //@}



  /// \name Vertex connectivity
  //@{
  /// Get an outgoing halfedge of a given vertex
  HalfedgeHandle halfedge_handle(VertexHandle _vh) const;
  /// Set the outgoing halfedge handle of a given vertex
  void set_halfedge_handle(VertexHandle _vh, HalfedgeHandle _heh);
  /// Get the coordinate of a vertex
  const Point& point(VertexHandle _vh) const;
  /// Get the coordinate of a vertex
  const Point& point(const Vertex& _v) const;
  /// Set the coordinate of a vertex
  void set_point(VertexHandle _vh, const Point& _p);
  /// Set the coordinate of a vertex
  void set_point(Vertex& _v, const Point& _p);
  //@}




  /// \name Halfedge connectivity
  //@{
  /// Get the vertex the halfedge points to
  VertexHandle to_vertex_handle(HalfedgeHandle _heh) const;
  /** Get the vertex the halfedge starts from (implemented as to-handle
      of the opposite halfedge, provided for convenience) */
  VertexHandle from_vertex_handle(HalfedgeHandle _heh) const;
  /// Set the to-vertex-handle of the halfedge
  void set_vertex_handle(HalfedgeHandle _heh, VertexHandle _vh);
  /** Get the face the halfedge belongs to.
      \note The handle is invalid if the halfedge is a boundary halfedge */
  FaceHandle face_handle(HalfedgeHandle _heh) const;
  /// Set the face the halfedge belongs to
  void set_face_handle(HalfedgeHandle _heh, FaceHandle _fh);
  /// Get the next halfedge handle
  HalfedgeHandle next_halfedge_handle(HalfedgeHandle _heh) const;
  /** Set the next halfedge handle.  \note If the previous halfedge is
      also stored (see OpenMesh::Attributes::PrevHalfedge) then this
      method also has to set this link) */
  void set_next_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _nheh);
  /** Get the previous halfedge of the given halfedge. The
      implementation should take care of an existing
      OpenMesh::Attributes::PrevHalfedge attribute. */
  HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh) const;
  /// Get the opposite halfedge
  HalfedgeHandle opposite_halfedge_handle(HalfedgeHandle _heh) const;
  /// Counter-clockwise rotate the given halfedge around its from vertex
  HalfedgeHandle ccw_rotated_halfedge_handle(HalfedgeHandle _heh) const;
  /// Clockwise rotate the given halfedge around its from vertex
  HalfedgeHandle cw_rotated_halfedge_handle(HalfedgeHandle _heh) const;
  /// Get the edge the current halfedge it contained in
  EdgeHandle edge_handle(HalfedgeHandle _heh) const;
  //@}



  /// \name Edge connectivity
  //@{
  /// Get the first or second halfedge of the given edge
  HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i) const;
  //@}



  /// \name Face connectivity
  //@{
  /// Get a halfedge belonging to the face
  HalfedgeHandle halfedge_handle(FaceHandle _fh) const;
  /// Set one halfedge of the face
  void set_halfedge_handle(FaceHandle _fh, HalfedgeHandle _heh);
  //@}


public: // Standard Property Management

  /// \name set/get value of a standard property
  //@{

  // vertex
  const Point& point(VertexHandle _vh) const; ///< Get position
  void set_point(VertexHandle _vh, const Point& _p); ///< Set position
  Point& point(VertexHandle _vh); ///< Convenience function

  const Normal& normal(VertexHandle _vh) const; ///< Get normal
  void set_normal(VertexHandle _vh, const Normal& _n); ///< Set normal

  const Normal& normal(HalfedgeHandle _heh) const; ///< Get normal of the to vertex of the given Halfedge (per face per vertex normals)
  void set_normal(HalfedgeHandle _heh, const Normal& _n); ///< Set normal of the to vertex of the given Halfedge (per face per vertex normals)

  const Color& color(VertexHandle _vh) const; ///< Get color
  void set_color(VertexHandle _vh, const Color& _c); ///< Set color

  const TexCoord1D& texcoord1D(VertexHandle _vh) const; ///< Get texture coordinate.
  void set_texcoord1D(VertexHandle _vh, const TexCoord1D& _t); ///< Set texture coordinate.

  const TexCoord2D& texcoord2D(VertexHandle _vh) const; ///< Get texture coordinate.
  void set_texcoord2D(VertexHandle _vh, const TexCoord2D& _t); ///< Set texture coordinate.

  const TexCoord3D& texcoord3D(VertexHandle _vh) const; ///< Get texture coordinate.
  void set_texcoord3D(VertexHandle _vh, const TexCoord3D& _t); ///< Set texture coordinate.

  const TexCoord1D& texcoord1D(HalfedgeHandle _hh) const; ///< Get texture coordinate of the to vertex for the current face (per face per vertex texcoords)
  void set_texcoord1D(HalfedgeHandle _hh, const TexCoord1D& _t); ///< Set texture coordinate of the to vertex of the given Halfedge (per face per vertex texcoords)

  const TexCoord2D& texcoord2D(HalfedgeHandle _hh) const; ///< Get texture coordinate of the to vertex for the current face (per face per vertex texcoords)
  void set_texcoord2D(HalfedgeHandle _hh, const TexCoord2D& _t); ///< Set texture coordinate of the to vertex of the given Halfedge (per face per vertex texcoords)

  const TexCoord3D& texcoord3D(HalfedgeHandle _hh) const; ///< Get texture coordinate of the to vertex for the current face (per face per vertex texcoords)
  void set_texcoord3D(HalfedgeHandle _hh, const TexCoord3D& _t); ///< Set texture coordinate of the to vertex of the given Halfedge (per face per vertex texcoords)

  const StatusInfo& status(VertexHandle _vh) const; ///< Get status
  StatusInfo& status(VertexHandle _vh); ///< Get status

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

  const Color& color(HalfedgeHandle _heh) const; ///< Get color
  void set_color(HalfedgeHandle _heh, const Color& _c); ///< Set color

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


  const StatusInfo& status(EdgeHandle _vh) const; ///< Get status
  StatusInfo& status(EdgeHandle _vh); ///< Get status

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

  const Color& color(FaceHandle _fh) const; ///< Get color
  void set_color(FaceHandle _fh, const Color& _c); ///< Set color

  const StatusInfo& status(FaceHandle _vh) const; ///< Get status
  StatusInfo& status(FaceHandle _vh); ///< Get status

  //@}

  /// \name Dynamically add standard properties
  //@{
  /// Request property
  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();
  //@}

  /// \name Remove standard properties
  //@{
  /// Remove property
  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();
  //@}

  /// \name Check availability of standard properties
  //@{
  /// Is property available?
  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

  /// \anchor concepts_kernelt_property_management

  /// \name Property management - add property
  //@{
  /// Add property.
  /// @copydoc OpenMesh::BaseKernel::add_property()
  template <typename T> bool add_property( [VEHFM]PropHandleT<T>& _ph,
                                           const std::string& _name = "" );
  //@}

  /// \name Property management - remove property
  //@{
  /// Remove property
  template <typename T> void remove_property( [VEHFM]PropHandleT<T>& );
  //@}

  /// \name Property management - get property by name
  //@{
  /// Get property handle by name
  template <typename T>
  bool get_property_handle( [VEHFM]PropHandleT<T>& ph, const std::string& _n ) const;
  //@}

  /// \name Property management - get property
  //@{
  /// Get property
  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;
  //@}

  /// \name Property management - get property value for an item
  //@{

  /// Get value for item represented by the handle.
  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:


  /// \name Low-level adding new items
  //@{
  /** Add a new (default) vertex.
      \internal */
  VertexHandle new_vertex();
  /** Add a new vertex with a given point coordinate.
      \internal */
  VertexHandle new_vertex(const Point& _p);
  /** Add a new vertex (copied from the given one).
      \internal */
  VertexHandle new_vertex(const Vertex& _v);
  /** Add a new edge from \c _start_vertex_handle to \c _end_vertex_handle.
      This method should add an edge (i.e. two opposite halfedges) and set
      the corresponding vertex handles of these halfedges.
      \internal
   */
  HalfedgeHandle new_edge(VertexHandle _start_vertex_handle,
			  VertexHandle _end_vertex_handle);

  /** Adding a new face
      \internal
  */
  FaceHandle new_face();
  /** Adding a new face (copied from a \c _f).
      \internal */
  FaceHandle new_face(const Face& _f);
  //@}


  // --- iterators ---

  /// \name Kernel item iterators
  //@{
  /** Kernel item iterator
      \internal */
  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 ---

  /// copy constructor: not used
  KernelT(const KernelT& _rhs);
};
};


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