SimplexData.h

Go to the documentation of this file.

#ifndef SimplexData_HEADER
#define SimplexData_HEADER

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include "MeshTypes.h"
#include <boost/foreach.hpp>
#include <list>

/***************************************************************************
 * Storage for the point location data needed by SVR.
 * We attach this to each simplex.  TODO: the information is better
 * stored in the vertices.
 *
 * This structure is fairly dumb; mostly it is just storage.
 *
 * TODO:
 * - if ambient == topological, there are no uppers to store
 * - if topological == 1, there are no lowers to store (just vertices)
 * It would be a SMOP to specialize the class for this.  This would almost halve
 * the overhead of each simplex (as of this writing, it is 60 bytes!)
 ***************************************************************************/
template <size_t ambient, size_t topological>
class SimplexData {
  typedef typename MeshTypes<ambient>::Vertex Vertex;
  typedef typename MeshTypes<ambient>::Ball Ball;
  typedef typename MeshTypes<ambient>::BallSet BallSet;
  typedef typename MeshTypes<ambient>::Point Point;

  // The ball is owned elsewhere, not here.  Important: the ball points to the
  // simplex whose data this is, so we can't here have a ref-counted pointer to
  // the ball, as that would make a loop.
  Ball *ball_;

  // TODO: these are a huge amount of storage!  Fixes:
  // (1) use a better list<> class (singly-linked, no size field)
  // (2) specialize for when there are no uppers/lowers (depends on dimension)
  BallSet uppers_;
  BallSet lowers_;

  public:
  typedef typename BallSet::const_iterator lower_it;
  typedef typename BallSet::const_iterator upper_it;
  typedef typename list<Vertex*>::const_iterator vertex_it;

  SimplexData() { ball_ = NULL; }
  ~SimplexData() { /* TODO: delete the ball. */ }

  Ball *toBall() const { return ball_; }

  void setBall(Ball *b) {
    assert(ball_ == NULL);
    ball_ = b;
    assert(ball_->topological() == topological);
  }

  bool isCrowded() const {
    BOUNDED_FOREACH(Vertex * v, ball_->begin_vertices(), ball_->end_vertices()) {
      if (v->template isCrowded<topological>()) {
        return true;
      }
    }
    return false;
  }

  Vertex *findWarpVertex(const Point& p, double& r2) const {
    Vertex *best = NULL;

    BOUNDED_FOREACH(Vertex * v, ball_->begin_vertices(), ball_->end_vertices()) {
      pair<Vertex*, double> p = v->findClosest(p, r2);
      r2 = p.second;
      best = p.first;
    }
    return best;
  }

  lower_it begin_lowers() const { return lowers_.begin(); }
  lower_it end_lowers() const { return lowers_.end(); }

  upper_it begin_uppers() const { return uppers_.begin(); }
  upper_it end_uppers() const { return uppers_.end(); }


  void removeLower(Ball *b) { assert(b->topological() < topological); lowers_.erase(b); }
  void blindlyAddLower(Ball *b) { assert(b->topological() < topological); lowers_.insert(b); }

  void removeUpper(Ball *b) { assert(b->topological() > topological); uppers_.erase(b); }
  void blindlyAddUpper(Ball *b) { assert(b->topological() > topological); uppers_.insert(b); }

  void unlink() {
    BOOST_FOREACH(Ball *lower, lowers_) {
      lower->removeUpper(ball_);
    }
    BOOST_FOREACH(Ball *upper, uppers_) {
      upper->removeLower(ball_);
    }
  }

  void gatherLowers(BallSet& output) const {
    output.insert(lowers_.begin(), lowers_.end());
  }

  void gatherUppers(BallSet& output) const {
    output.insert(uppers_.begin(), uppers_.end());
  }
};

#endif

---