IndexedEdgePolyhedron.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_IndexedEdgePolyhedron_h__)
#define __geom_IndexedEdgePolyhedron_h__

// If we are debugging the whole geom package.
#if defined(DEBUG_geom) && !defined(DEBUG_IndexedEdgePolyhedron)
#define DEBUG_IndexedEdgePolyhedron
#endif

#include "../kernel/BBox.h"

#include <vector>

BEGIN_NAMESPACE_GEOM


template<typename T = double>
class IndexedEdgePolyhedron {
  //
  // Public types.
  //

public:

  typedef T Number;
  typedef int SizeType;
  typedef ads::FixedArray<3,Number> Point;
  typedef ads::FixedArray<2,int> IndexedEdge;

  //
  // Private types.
  //

private:

  typedef std::vector<Point> VertexContainer;

  typedef std::vector<IndexedEdge> EdgeContainer;

  //
  // More public types.
  //

public:

  typedef typename VertexContainer::const_iterator VertexConstIterator;
  typedef typename VertexContainer::iterator VertexIterator;
  typedef typename EdgeContainer::const_iterator EdgeConstIterator;
  typedef typename EdgeContainer::iterator EdgeIterator;

  // 
  // Data
  //

private:

  VertexContainer _vertices;

  EdgeContainer _edges;
  
public:

  //--------------------------------------------------------------------------
  // @{

  IndexedEdgePolyhedron() :
    _vertices(),
    _edges() 
  {}
  
  IndexedEdgePolyhedron(const IndexedEdgePolyhedron& other) : 
    _vertices(other._vertices),
    _edges(other._edges) 
  {}

  IndexedEdgePolyhedron& 
  operator=(const IndexedEdgePolyhedron& other);
  
  ~IndexedEdgePolyhedron()
  {}

  //--------------------------------------------------------------------------
  // @{

  void 
  computeBBox(BBox<3,Number>* bb) const;

  //--------------------------------------------------------------------------
  // @{

  SizeType
  getVerticesSize() const {
    return SizeType(_vertices.size());
  }

  SizeType
  getEdgesSize() const {
    return SizeType(_edges.size());
  }

  const Point& 
  getVertex(const int n) const { 
    return _vertices[n]; 
  }

  const IndexedEdge& 
  getEdge(const int n) const { 
    return _edges[n];
  }

  const Point&
  getEdgeSource(const int n) const {
    return _vertices[_edges[n][0]];
  }

  const Point&
  getEdgeTarget(const int n) const {
    return _vertices[_edges[n][1]];
  }

  //--------------------------------------------------------------------------
  // @{

  // Return the beginning of the vertices.
  VertexIterator
  getVerticesBeginning() {
    return _vertices.begin();
  }

  // Return the end of the vertices.
  VertexIterator
  getVerticesEnd() {
    return _vertices.end();
  }

  // Return the beginning of the indexed edges.
  EdgeIterator
  getEdgesBeginning() {
    return _edges.begin();
  }

  // Return the end of the indexed edges.
  EdgeIterator
  getEdgesEnd() {
    return _edges.end();
  }

  // CONTINUE REMOVE
#if 0
  std::vector<Point>& 
  vertices() { 
    return _vertices; 
  }

  std::vector<IndexedEdge>& 
  edges() { 
    return _edges; 
  }
#endif

  void
  insertVertex(const Point& x) {
    _vertices.push_back(x);
  }

  void 
  insertEdge(const int i, const int j) {
#ifdef DEBUG_IndexedEdgePolyhedron
    assert(0 <= i && i < getVerticesSize() && 
           0 <= j && j < getVerticesSize());
#endif
    _edges.push_back(IndexedEdge(i, j));
  }

  void
  clear() {
    _vertices.clear();
    _edges.clear();
  }

  //--------------------------------------------------------------------------

  bool
  isEqualTo(const IndexedEdgePolyhedron& x) const {
    return _vertices == x._vertices && _edges == x._edges; 
  }


};


//-----------------------------------------------------------------------------
// Equality Operators
//-----------------------------------------------------------------------------



template<typename T>
inline
bool 
operator==(const IndexedEdgePolyhedron<T>& a, 
           const IndexedEdgePolyhedron<T>& b) { 
  return a.isEqualTo(b);
}


template<typename T>
inline
bool 
operator!=(const IndexedEdgePolyhedron<T>& a, 
           const IndexedEdgePolyhedron<T>& b) { 
  return !(a == b);
}

END_NAMESPACE_GEOM

#define __geom_IndexedEdgePolyhedron_ipp__
#include "IndexedEdgePolyhedron.ipp"
#undef __geom_IndexedEdgePolyhedron_ipp__

#endif

---