IndSimpSetIncAdj.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_IndSimpSetIncAdj_h__)
#define __geom_IndSimpSetIncAdj_h__

#if defined(DEBUG_geom) && !defined(DEBUG_IndSimpSetIncAdj)
#define DEBUG_IndSimpSetIncAdj
#endif

#ifdef DEBUG_IndSimpSetIncAdj
#ifndef DEBUG_IndSimpSet
#define DEBUG_IndSimpSet
#endif
#endif

#include "IndSimpSet.h"
#include "SimplexAdj.h"
#include "VertexSimplexInc.h"
#include "IssiaFaceIterator.h"

BEGIN_NAMESPACE_GEOM


template<int _N,
         int _M = _N,
         bool _A = true,
         typename T = double,
         typename V = ads::FixedArray<_N,T>,
         typename IS = Simplex<_M,int> >
class IndSimpSetIncAdj :
  public IndSimpSet<_N,_M,_A,T,V,IS> {
  //
  // The base type.
  //

public:

  typedef IndSimpSet<_N,_M,_A,T,V,IS> Base;

  //
  // Enumerations.
  //

public:

  enum {N = Base::N, M = Base::M, A = Base::A};

  //
  // Public types.
  //

public:

  //
  // Inherited from IndSimpSet.
  //

  typedef typename Base::Number Number;
  typedef typename Base::Vertex Vertex;
  typedef typename Base::Simplex Simplex;
  typedef typename Base::SimplexFace SimplexFace;

  typedef typename Base::IndexedSimplex IndexedSimplex;
  typedef typename Base::IndexedSimplexFace IndexedSimplexFace;

  typedef typename Base::VertexContainer VertexContainer;
  typedef typename Base::VertexConstIterator VertexConstIterator;
  typedef typename Base::VertexIterator VertexIterator;

  typedef typename Base::IndexedSimplexContainer IndexedSimplexContainer;
  typedef typename Base::IndexedSimplexConstIterator
  IndexedSimplexConstIterator;
  typedef typename Base::IndexedSimplexIterator IndexedSimplexIterator;

  typedef typename Base::SimplexConstIterator SimplexConstIterator;

  typedef typename Base::SizeType SizeType;

  //
  // New types.
  //

  typedef VertexSimplexInc<M> IncidenceContainer;
  typedef typename IncidenceContainer::ConstIterator IncidenceConstIterator;

  typedef SimplexAdj<M> AdjacencyContainer;

  // Faces.
  
  typedef std::pair<int,int> Face;
  typedef IssiaFaceIterator<IndSimpSetIncAdj> FaceIterator;

  //
  // Member data.
  //

private:

  IncidenceContainer _vertexSimplexIncidence;
  AdjacencyContainer _simplexAdjacencies;

public:

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

  IndSimpSetIncAdj() :
    Base(),
    _vertexSimplexIncidence(),
    _simplexAdjacencies()
  {}

  IndSimpSetIncAdj(const IndSimpSetIncAdj& other) :
    Base(other),
    _vertexSimplexIncidence(other._vertexSimplexIncidence),
    _simplexAdjacencies(other._simplexAdjacencies)
  {}

  IndSimpSetIncAdj& 
  operator=(const IndSimpSetIncAdj& other) {
    if (&other != this) {
      Base::operator=(other);
      _vertexSimplexIncidence = other._vertexSimplexIncidence;
      _simplexAdjacencies = other._simplexAdjacencies;
    }
    return *this;
  }


  template <bool A1, bool A2>
  IndSimpSetIncAdj(const ads::Array<1,Vertex,A1>& vertices, 
                   const ads::Array<1,IndexedSimplex,A2>& indexedSimplices) :
    Base(vertices, indexedSimplices),
    _vertexSimplexIncidence(getVerticesSize(), getIndexedSimplices()),
    _simplexAdjacencies(getIndexedSimplices(), _vertexSimplexIncidence)
  {}


  template <bool A1, bool A2>
  void
  build(const ads::Array<1,Vertex,A1>& vertices, 
        const ads::Array<1,IndexedSimplex,A2>& indexedSimplices) {
    Base::build(vertices, indexedSimplices);
    updateTopology();
  }


  IndSimpSetIncAdj(const SizeType numVertices, 
                   void* verticesData,
                   const SizeType numSimplices, 
                   void* indexedSimplicesData) :
    Base(numVertices, verticesData, numSimplices, 
              indexedSimplicesData),
    _vertexSimplexIncidence(getVerticesSize(), getIndexedSimplices()),
    _simplexAdjacencies(getIndexedSimplices(), _vertexSimplexIncidence)
  {}


  void
  build(const SizeType numVertices, void* verticesData,
        const SizeType numSimplices, void* indexedSimplicesData) {
    Base::build(numVertices, verticesData, numSimplices, indexedSimplicesData);
    updateTopology();
  }


  IndSimpSetIncAdj(const SizeType numVertices, 
                   const void* verticesData,
                   const SizeType numSimplices, 
                   const void* indexedSimplicesData) :
    Base(numVertices, verticesData, numSimplices, 
              indexedSimplicesData),
    _vertexSimplexIncidence(getVerticesSize(), getIndexedSimplices()),
    _simplexAdjacencies(getIndexedSimplices(), _vertexSimplexIncidence)
  {}


  void
  build(const SizeType numVertices, const void* verticesData,
        const SizeType numSimplices, const void* indexedSimplicesData) {
    Base::build(numVertices, verticesData, numSimplices, indexedSimplicesData);
    updateTopology();
  }


  IndSimpSetIncAdj(const SizeType numVertices, const SizeType numSimplices) :
    Base(numVertices, numSimplices),
    _vertexSimplexIncidence(),
    _simplexAdjacencies()
  {}


  void
  build(const SizeType numVertices, const SizeType numSimplices) {
    Base::build(numVertices, numSimplices);
    {
      // Clear the vertex-simplex incidence relations.
      IncidenceContainer empty;
      _vertexSimplexIncidence.swap(empty);
    }
    {
      // Clear the adjacency relations.
      AdjacencyContainer empty;
      _simplexAdjacencies.swap(empty);
    }
  }

  void
  swap(IndSimpSetIncAdj& x) {
    Base::swap(x);
    _vertexSimplexIncidence.swap(x._vertexSimplexIncidence);
    _simplexAdjacencies.swap(x._simplexAdjacencies);
  }


  IndSimpSetIncAdj(const Base& iss) :
    Base(iss),
    _vertexSimplexIncidence(getVerticesSize(), getIndexedSimplices()),
    _simplexAdjacencies(getIndexedSimplices(), _vertexSimplexIncidence)
  {}

  virtual
  ~IndSimpSetIncAdj()
  {}

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


  using Base::getSpaceDimension;

  using Base::getVerticesSize;

  using Base::areVerticesEmpty;

  using Base::getVerticesBeginning;

  using Base::getVerticesEnd;

  using Base::getVertex;

  using Base::getVertices;

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


  using Base::getSimplexDimension;

  using Base::getSimplicesSize;

  using Base::areSimplicesEmpty;

  using Base::isEmpty;

  using Base::getIndexedSimplicesBeginning;

  using Base::getIndexedSimplicesEnd;

  using Base::getIndexedSimplex;

  using Base::getIndexedSimplices;

  using Base::getSimplicesBeginning;

  using Base::getSimplicesEnd;

  using Base::getSimplexVertex;

  using Base::getSimplex;

  //using Base::getSimplex;

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

  const IncidenceContainer&
  getVertexSimplexIncidence() const {
    return _vertexSimplexIncidence;
  }

  SizeType
  getIncidentSize(const int n) const {
    return _vertexSimplexIncidence.getSize(n);
  }

  bool 
  isIncidentEmpty(const int n) const { 
    return _vertexSimplexIncidence.isEmpty(n);
  }

  IncidenceConstIterator 
  getIncidentBeginning(const int n) const { 
    return _vertexSimplexIncidence.getBeginning(n);
  }

  IncidenceConstIterator 
  getIncidentEnd(const int n) const { 
    return _vertexSimplexIncidence.getEnd(n);
  }

  int
  getIncident(const int n, const int m) const {
    return _vertexSimplexIncidence(n, m);
  }

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

  const AdjacencyContainer&
  getSimplexAdjacencies() const {
    return _simplexAdjacencies;
  }

  int
  getAdjacentSize(const int n) const {
    return _simplexAdjacencies.getSize(n);
  }


  int
  getAdjacent(const int n, const int m) const {
    return _simplexAdjacencies(n, m);
  }

  int
  getMirrorIndex(const int n, const int m) const {
    const int a = getAdjacent(n, m);
    if (a == -1) {
      return -1;
    }
#ifdef DEBUG_geom
    const int mi = _simplexAdjacencies(a).find_index(n);
    assert(0 <= mi && mi < M + 1);
    return mi;
#else
    return _simplexAdjacencies(a).find_index(n);
#endif
  }

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


  SizeType
  computeFacesSize() const {
    return int(std::distance(getFacesBeginning(), getFacesEnd()));
  }

  FaceIterator
  getFacesBeginning() const {
    FaceIterator x(this, 0);
    return x;
  }

  FaceIterator
  getFacesEnd() const {
    return FaceIterator(this, getSimplicesSize());
  }

  bool
  isOnBoundary(const Face& f) const {
    return getAdjacent(f.first, f.second) == -1;
  }

  bool
  isOnBoundary(const FaceIterator& f) const {
    return isOnBoundary(*f);
  }

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


  bool
  isVertexOnBoundary(int index) const;

  //--------------------------------------------------------------------------
  // Vertex Manipulators
  // Inherited from IndSimpSet.
  // These are already listed with the vertex accessors.

  // Return an iterator to the beginning of the vertices.
  //using Base::getVerticesBeginning;

  // Return an iterator to the end of the vertices.
  //using Base::getVerticesEnd;

  // Return a reference to the vertex container.
  //using Base::getVertices;

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

  // Return an iterator to the beginning of the indexed simplices.
  //using Base::getIndexedSimplicesBeginning;

  // Return an iterator to the end of the indexed simplices.
  //using Base::getIndexedSimplicesEnd;

  // Return a reference to the indexed simplex container.
  //using Base::getIndexedSimplices;

  void
  reverseOrientation(const int n) {
    std::swap(getIndexedSimplices()[n][0], getIndexedSimplices()[n][1]);
    std::swap(_simplexAdjacencies(n)[0], _simplexAdjacencies(n)[1]);
  }

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


  virtual
  void
  updateTopology() {
    _vertexSimplexIncidence.build(getVerticesSize(), getIndexedSimplices());
    _simplexAdjacencies.build(getIndexedSimplices(), _vertexSimplexIncidence);
  }
  
};

END_NAMESPACE_GEOM

#define __geom_IndSimpSetIncAdj_ipp__
#include "IndSimpSetIncAdj.ipp"
#undef __geom_IndSimpSetIncAdj_ipp__

#endif

---