SimpMeshRed.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_SimpMeshRed_h__)
#define __geom_mesh_simplicial_SimpMeshRed_h__

#include "SmrNode.h"
#include "SmrCell.h"
#include "FaceIterator.h"
#include "EdgeIterator.h"

#include "../iss/IndSimpSetIncAdj.h"
#include "../simplex/Simplex.h"

#include "../../../ads/functor/composite_compare.h"
#include "../../../ads/iterator/MemFunIterator.h"
#include "../../../ads/algorithm/Triplet.h"

#include <list>
#include <set>
#include <map>

#include <cassert>

BEGIN_NAMESPACE_GEOM


template<int _N, 
         int _M = _N,
         typename T = double,
         template<class> class _Node = SmrNode,
         template<class> class _Cell = SmrCell,
         // CONTINUE
         // Had to add the allocator class to appease MSVC++.
         // See notes below.
         template<class _Elem,
                  class = std::allocator<_Elem> > class Container =
         std::list>
class SimpMeshRed {
  //
  // Enumerations.
  //

public:

  enum {N = _N, M = _M};
  
  //
  // Types.
  //

private:

  // CONTINUE
  // I should be able to do this more cleanly.  See page 112 of
  // "C++ Templates, The Complete Guide".  I have to add the allocator to
  // get MSVC++ to compile it.
  typedef Container<_Node<SimpMeshRed>, 
                    std::allocator<_Node<SimpMeshRed> > > NodeContainer;
  typedef Container<_Cell<SimpMeshRed>,
                    std::allocator<_Cell<SimpMeshRed> > > CellContainer;

public:

  //
  // Nodes.
  //

  typedef typename NodeContainer::value_type Node;
  typedef typename NodeContainer::iterator NodeIterator;
  typedef typename NodeContainer::const_iterator NodeConstIterator;

  //
  // Cells.
  //

  typedef typename CellContainer::value_type Cell;
  typedef typename CellContainer::iterator CellIterator;
  typedef typename CellContainer::const_iterator CellConstIterator;

  //
  // Faces.
  //
  
  typedef std::pair<CellConstIterator,int> ConstFace;
  typedef FaceIterator<M,ConstFace,CellConstIterator> 
  FaceConstIterator;
  typedef std::pair<CellIterator,int> Face;
  typedef FaceIterator<M,Face,CellIterator> FaceIterator;

  //
  // Edges.
  //

  typedef ads::Triplet<CellConstIterator,int,int> ConstEdge;
  typedef EdgeIterator<SimpMeshRed,true> EdgeConstIterator;
  typedef ads::Triplet<CellIterator,int,int> Edge;
  typedef EdgeIterator<SimpMeshRed,false> EdgeIterator;

  //
  // Miscellaneous.
  //

  typedef T Number;
  typedef typename Node::Vertex Vertex;
  typedef BBox<N,Number> BBox;

  typedef int SizeType;
  typedef typename NodeContainer::difference_type DifferenceType;

  //
  // Simplex
  //

  typedef Simplex<M,int> IndexedSimplex;
  typedef Simplex<M,Vertex> Simplex;

  //
  // Node member function iterators.
  //

  typedef ads::MemFunIterator<NodeConstIterator,Node, const Vertex&,true>
  VertexIterator;
  typedef ads::MemFunIterator<NodeConstIterator,Node,int,true>
  NodeIdentifierIterator;
  typedef ads::MemFunIterator<CellConstIterator,Cell,int,true>
  CellIdentifierIterator;

  //
  // Indexed simplex iterator.
  //

#define __geom_mesh_simplicial_SMR_IndSimpIter_ipp__
#include "SMR_IndSimpIter.ipp"
#undef __geom_mesh_simplicial_SMR_IndSimpIter_ipp__

  typedef IndSimpIter IndexedSimplexIterator;

  //
  // Simplex iterator.
  //

#define __geom_mesh_simplicial_SMR_SimpIter_ipp__
#include "SMR_SimpIter.ipp"
#undef __geom_mesh_simplicial_SMR_SimpIter_ipp__

  typedef SimpIter SimplexIterator;

  struct NodeIteratorCompare : 
    public std::binary_function<NodeIterator, NodeIterator, bool> {
    bool
    operator()(const NodeIterator& x, const NodeIterator& y) const {
      return x->getIdentifier() < y->getIdentifier();
    }
  };

  struct CellIteratorCompare : 
    public std::binary_function<CellIterator, CellIterator, bool> {
    bool
    operator()(const CellIterator& x, const CellIterator& y) const {
      return x->getIdentifier() < y->getIdentifier();
    }
  };

  struct FaceCompare : 
    public std::binary_function<Face, Face, bool> {
    bool
    operator()(const Face& x, const Face& y) const {
      return x.first->getIdentifier() < y.first->getIdentifier() ||
        (x.first->getIdentifier() == y.first->getIdentifier() &&
          x.second < y.second);
    }
  };

  struct FaceIteratorCompare : 
    public std::binary_function<FaceIterator, FaceIterator, bool> {
    bool
    operator()(const FaceIterator& x, const FaceIterator& y) const {
      return x->first->getIdentifier() < y->first->getIdentifier() ||
        (x->first->getIdentifier() == y->first->getIdentifier() &&
          x->second < y->second);
    }
  };

  typedef std::set<NodeIterator, NodeIteratorCompare> NodeIteratorSet;
  typedef std::set<CellIterator, CellIteratorCompare> CellIteratorSet;
  typedef std::set<Face, FaceCompare> FaceSet;
  typedef std::set<FaceIterator, FaceIteratorCompare> FaceIteratorSet;


  //
  // Data
  //
    
private:
      
  NodeContainer _nodes;
  CellContainer _cells;
     
public:

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

  SimpMeshRed() :
    _nodes(),
    _cells()
  {}

  SimpMeshRed(const SimpMeshRed& other) :
    _nodes(other._nodes),
    _cells(other._cells)
  {}

  template< bool A, typename V, typename IS >
  SimpMeshRed(const IndSimpSet<N,M,A,Number,V,IS>& iss) :
    _nodes(),
    _cells() {
    build(iss);
  }

  SimpMeshRed& 
  operator=(const SimpMeshRed& other) {
    if (&other != this) {
      _nodes = other._nodes;
      _cells = other._cells;
    }
    return *this;
  }


  template<typename VertInIter, typename SimpInIter>
  void
  build(VertInIter verticesBeginning, VertInIter verticesEnd, 
        SimpInIter simplicesBeginning, SimpInIter simplicesEnd);
  
  template< bool A, typename V, typename IS >
  void
  build(const IndSimpSet<N,M,A,Number,V,IS>& iss) {
    build(iss.getVerticesBeginning(), iss.getVerticesEnd(),
          iss.getIndexedSimplicesBeginning(), iss.getIndexedSimplicesEnd());
  }

  void
  swap(SimpMeshRed& x) {
    _nodes.swap(x._nodes);
    _cells.swap(x._cells);
  }

  void
  clear() {
    _nodes.clear();
    _cells.clear();
  }

  ~SimpMeshRed()
  {}

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

  int
  getSpaceDimension() const {
    return N;
  }

  int
  getSimplexDimension() const {
    return M;
  }
  
  //--------------------------------------------------------------------------

  bool
  areNodesEmpty() const {
    return _nodes.empty();
  }


  SizeType
  computeNodesSize() const {
    return SizeType(_nodes.size());
  }

  NodeConstIterator
  getNodesBeginning() const {
    return _nodes.begin();
  }

  NodeConstIterator
  getNodesEnd() const {
    return _nodes.end();
  }

  VertexIterator
  getVerticesBeginning() const {
    return VertexIterator(&Node::getVertex, _nodes.begin());
  }

  VertexIterator
  getVerticesEnd() const {
    return VertexIterator(&Node::getVertex, _nodes.end());
  }

  NodeIdentifierIterator
  getNodeIdentifiersBeginning() const {
    return NodeIdentifierIterator(&Node::getIdentifier, _nodes.begin());
  }

  NodeIdentifierIterator
  getNodeIdentifiersEnd() const {
    return NodeIdentifierIterator(&Node::getIdentifier, _nodes.end());
  }


  int
  computeMaximumNodeIdentifier() const {
    if (areNodesEmpty()) {
      // Return -1 because one more than the "maximum" is then 0.
      return -1;
    }
    return *std::max_element(getNodeIdentifiersBeginning(),
                             getNodeIdentifiersEnd());
  }

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

  bool
  areCellsEmpty() const {
    return _cells.empty();
  }


  SizeType
  computeCellsSize() const {
    return SizeType(_cells.size());
  }

  CellConstIterator
  getCellsBeginning() const {
    return _cells.begin();
  }

  CellConstIterator
  getCellsEnd() const {
    return _cells.end();
  }

  void
  getSimplex(CellConstIterator i, Simplex* s) const {
    for (int m = 0; m != M+1; ++m) {
      (*s)[m] = i->getNode(m)->getVertex();
    }
  }

  CellIdentifierIterator
  getCellIdentifiersBeginning() const {
    return CellIdentifierIterator(&Cell::getIdentifier, _cells.begin());
  }

  CellIdentifierIterator
  getCellIdentifiersEnd() const {
    return CellIdentifierIterator(&Cell::getIdentifier, _cells.end());
  }


  int
  computeMaximumCellIdentifier() const {
    if (areCellsEmpty()) {
      // Return -1 because one more than the "maximum" is then 0.
      return -1;
    }
    return *std::max_element(getCellIdentifiersBeginning(),
                             getCellIdentifiersEnd());
  }

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

  IndexedSimplexIterator
  getIndexedSimplicesBeginning() const {
    return IndexedSimplexIterator(getCellsBeginning());
  }

  IndexedSimplexIterator
  getIndexedSimplicesEnd() const {
    return IndexedSimplexIterator(getCellsEnd());
  }

  SimplexIterator
  getSimplicesBeginning() const {
    return SimplexIterator(getCellsBeginning());
  }

  SimplexIterator
  getSimplicesEnd() const {
    return SimplexIterator(getCellsEnd());
  }

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


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

  FaceConstIterator
  getFacesBeginning() const {
    FaceConstIterator x(getCellsBeginning(), getCellsEnd());
    return x;
  }

  FaceConstIterator
  getFacesEnd() const {
    return FaceConstIterator(getCellsEnd(), getCellsEnd());
  }

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


  SizeType
  computeEdgesSize() const {
    return std::distance(getEdgesBeginning(), getEdgesEnd());
  }

  EdgeConstIterator
  getEdgesBeginning() const {
    EdgeConstIterator x(getCellsBeginning(), getCellsEnd());
    return x;
  }

  EdgeConstIterator
  getEdgesEnd() const {
    return EdgeConstIterator(getCellsEnd(), getCellsEnd());
  }

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

  NodeIterator
  getNodesBeginning() {
    return _nodes.begin();
  }

  NodeIterator
  getNodesEnd() {
    return _nodes.end();
  }


  void
  setNodeIdentifiers() const;

  template<typename VertexInIter>
  void
  setVertices(VertexInIter begin, VertexInIter end) {
    for (NodeIterator i = getNodesBeginning(); i != getNodesEnd(); 
         ++i, ++begin) {
#ifdef DEBUG_SimpMeshRed
      assert(begin != end);
#endif
      i->setVertex(*begin);
    }
    assert(begin == end);
  }

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

  CellIterator
  getCellsBeginning() {
    return _cells.begin();
  }

  CellIterator
  getCellsEnd() {
    return _cells.end();
  }
  

  void
  setCellIdentifiers() const;

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

  FaceIterator
  getFacesBeginning() {
    return FaceIterator(getCellsBeginning(), getCellsEnd());
  }

  FaceIterator
  getFacesEnd() {
    return FaceIterator(getCellsEnd(), getCellsEnd());
  }

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

  EdgeIterator
  getEdgesBeginning() {
    return EdgeIterator(getCellsBeginning(), getCellsEnd());
  }

  EdgeIterator
  getEdgesEnd() {
    return EdgeIterator(getCellsEnd(), getCellsEnd());
  }

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


  NodeIterator
  insertNode(const Node& node = Node());

  NodeIterator
  insertNode(const NodeIterator node) {
    return insert_vertex(*node);
  }


  void
  eraseNode(const NodeIterator node) {
    _nodes.erase(node);
  }


  void
  merge(NodeIterator x, NodeIterator y) {
#if 0
    // CONTINUE
    std::cerr << "Merge " << x->getIdentifier() << " "
              << y->getIdentifier() << "\n";
#endif
    assert(x != y);
    // Merge the vertex-simplex incidences.
    x->insertCells(y->getCellIteratorsBeginning(), y->getCellIteratorsEnd());
    // Fix the simplex-vertex incidences.
    y->replace(x);
    // Erase the second vertex.
    eraseNode(y);
  }

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

  CellIterator
  insertCell(const Cell& c = Cell());

  CellIterator
  insertCell(const CellIterator c) {
    return insertCell(*c);
  }


  void
  eraseCell(const CellIterator c) {
    c->unlink();
    _cells.erase(c);
  }


  template<typename InIter>
  void
  eraseCells(InIter begin, InIter end) {
    for (; begin != end; ++begin) {
      eraseCell(*begin);
    }
  }


private:

  /* CONTINUE REMOVE
  template<class Map>
  void
  map_NodeIterators_to_indices(Map& x) const;
  */

  void
  buildCellAdjacencies();
  
};

END_NAMESPACE_GEOM

#define __geom_mesh_simplicial_SimpMeshRed_ipp__
#include "SimpMeshRed.ipp"
#undef __geom_mesh_simplicial_SimpMeshRed_ipp__

#endif

---