meshkernel.hh

penMesh is a generic and efficient data structure for representing and manipulating polygonal meshes

  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 Color& color(VertexHandle _vh) const; ///< Get color
  void set_color(VertexHandle _vh, const Color& _c) ///< Set color

  const TexCoord& texcoord(VertexHandle _vh) const; ///< Get texture coordinate.
  void set_texcoord(VertexHandle _vh, const TexCoord& _t); ///< Set texture coordinate.

  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

  // edge
  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_texcoords();
  void request_vertex_status();

  void request_halfedge_status();

  void request_edge_status();

  void request_face_normals();
  void request_face_colors();
  void request_face_status();
  //@}

  /// \name Remove standard properties
  //@{
  /// Remove property
  void release_vertex_normals();
  void release_vertex_colors();
  void release_vertex_texcoords();
  void release_vertex_status();

  void release_halfedge_status();

  void release_edge_status();

  void release_face_normals();
  void release_face_colors();
  void release_face_status();
  //@}

  /// \name Check availability of standard properties
  //@{
  /// Is property available?
  bool has_vertex_normals()   const;
  bool has_vertex_colors()    const;
  bool has_vertex_texcoords() const;
  bool has_vertex_status()    const;
  bool has_edge_status()      const;
  bool has_halfedge_status()  const;
  bool has_face_normals()     const;
  bool has_face_colors()      const;
  bool has_face_status()      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
//=============================================================================