ProtectedBall.h

Go to the documentation of this file.

#ifndef ProtectedBall_HEADER
#define ProtectedBall_HEADER

#include <geometry/Circles.h>
#include <utilities/hash.h>
#include "RefineVertex.h"
#include "SplitData.h"
#include <string>
#include "GenericMesh.h"
#include "MeshTypes.h"
using namespace std;

/* signature BALL =
   sig
     type ball
     type point
     val center : ball -> (point * real)
     val split : ball -> unit
     val encroached : ball * point -> bool
   end
   */

/***************************************************************************
 * Wrap a simplex in arbitrary dimension and protect it against encroachment.
 *
 * This is the object used in SVR to communicate between dimensions.
 * A simplex s in dimension i stores pointers to all lower-dimensional
 * protected balls b that s intersects (if b is on a sub-feature of the feature
 * that s is on).  The reverse pointer is also kept by the simplex that b
 * protects (furthermore, s points to higher-dimensional protected balls).
 *
 * The work queue and the main loop use the protected balls to avoid needing to
 * think hard about dimension.  This simplifies the code, though type safety
 * (and thus runtime, since we'd eliminate runtime checks) would be improved
 * by using appropriate-dimension simplices instead.  The old SML code did that
 * and was largely illegible, so the current approach is prefered.
 ***************************************************************************/
template <size_t amb>
struct ProtectedBall {
  typedef Geometry::CenterRadius<amb> CenterRadius;
  typedef ::SplitData<amb> SplitData;
  typedef typename MeshTypes<amb>::BallSet BallSet;
  typedef typename MeshTypes<amb>::Vertex Vertex;
  typedef typename MeshTypes<amb>::GenericMesh GenericMesh;

  virtual ~ProtectedBall() { }

  virtual size_t topological() const = 0;
  static size_t ambient() { return amb; }
  virtual const GenericMesh *getMesh() const = 0;
  virtual void gatherVertices(typename Vertex::VertexUniqueList&) const = 0;
  virtual bool has(const Vertex*) const = 0;

  // Functions that query mesh state and could be specific-dimensional.

  virtual bool isLive() const = 0; //<! Is this ball still to be protected?
  virtual CenterRadius center() const = 0; //<! Center/radius of the ball
  virtual double radiusEdge2() const = 0; //<! Geometry of the underlying simplex.
  virtual double computeSigma() const = 0; //<! Aspect ratio (as volume / e^3).

  // Functions that query cross-dimensional state.

  virtual bool isResolved() const = 0; //<! Is this ball resolved in the top mesh?
  virtual bool encroachedBy(const Vertex*) const = 0; //<! True if the vertex lies in the open ball (this is implemented as an approximate test)
  virtual bool inSphereExact(const Vertex*) const = 0; //<! True if the vertex lies in the open ball (robust test; v must be on the plane of b)
  virtual void gatherUppers(BallSet&) const = 0; //<! Gather all up-pointers: pointers to higher-dimensional balls that point to this ball.
  virtual void gatherLowers(BallSet&) const = 0; //<! Gather all down-pointers: all balls that lie on a sub-feature of this ball's feature, and that intersect this ball.


  virtual bool split(SplitData&, Vertex *hint=0, bool force=false) = 0;

  // Functions that update cross-dimensional state.

  virtual void blindlyAddUpper(ProtectedBall *up) = 0; //<! Add an up-pointer.
  virtual void blindlyAddLower(ProtectedBall *lower) = 0; //<! Add a down-pointer.
  virtual void removeUpper(ProtectedBall *up) = 0; //<! Remove an up-pointer.
  virtual void removeLower(ProtectedBall *lower) = 0; //<! Remove a down-pointer.

  virtual void checkAddLower(ProtectedBall *lower) = 0; //<! Add a down-pointer if the balls intersect.  We also set lower's up-pointer.

  virtual std::string toString() const = 0;


  bool approximatelyIntersects(const CenterRadius& other) const {
    return center().approximatelyIntersects(other);
  }

  bool approximatelyIntersects(ProtectedBall *other) const {
    return approximatelyIntersects(other->center());
  }
};

template <class Mesh>
struct PBall : public ProtectedBall<Mesh::ambient_dimension> {
  static const int ambient = Mesh::ambient_dimension;
  typedef ProtectedBall<ambient> super;
  typedef ProtectedBall<ambient> Ball;
  typedef typename super::CenterRadius CenterRadius;
  typedef typename super::Vertex Vertex;
  typedef ::SplitData<ambient> SplitData;

  /*
  static const size_t ambient = Mesh::ambient_dimension;
  static const size_t topological = Mesh::topological_dimension;
  */

  typedef typename Mesh::Simplex Simplex;

  PBall(Mesh *mesh, const Simplex& s): s_(s), mesh_(mesh) {
    mesh->setBall(s_, this);
  }

  const Simplex& toSimplex() const { return s_; }

  virtual size_t topological() const { return Mesh::topological_dimension; }

  virtual GenericMesh<ambient> *getMesh() const { return mesh_; }

  virtual void gatherVertices(typename Vertex::VertexUniqueList& vset) const {
    BOOST_FOREACH(Vertex *v, s_) {
      vset.insert(v);
    }
  }
  virtual bool has(const Vertex* v) const {
    return s_.has(v);
  }

  virtual bool isLive() const {
    return mesh_->isMember(s_);
  }

  virtual CenterRadius center() const {
    return mesh_->circumcenter(s_);
  }

  virtual double radiusEdge2() const {
    return mesh_->radiusEdge2(s_);
  }
  virtual double computeSigma() const {
    return mesh_->computeSigma(s_);
  }


  virtual bool encroachedBy(const Vertex *v) const {
    return mesh_->encroachedBy(s_, v);
  }

  virtual bool inSphereExact(const Vertex *v) const {
    return mesh_->inSphereExact(s_, v);
  }

  virtual bool isResolved() const {
    return mesh_->isResolved(s_);
  }

  virtual void gatherUppers(typename super::BallSet& set) const {
    mesh_->gatherUppers(s_, set);
  }

  virtual void gatherLowers(typename super::BallSet& set) const {
    mesh_->gatherLowers(s_, set);
  }


  virtual bool split(SplitData& sdata, Vertex *inserthint, bool force) {
    return mesh_->split(s_, sdata, inserthint, force);
  }

  virtual void blindlyAddUpper(Ball *up) {
    mesh_->blindlyAddUpper(s_, up);
  }

  virtual void blindlyAddLower(Ball *lower) {
    mesh_->blindlyAddLower(s_, lower);
  }

  virtual void removeUpper(Ball *up) {
    mesh_->removeUpper(s_, up);
  }

  virtual void removeLower(Ball *lower) {
    mesh_->removeLower(s_, lower);
  }

  virtual void checkAddLower(Ball *lower) {
    mesh_->checkAddLower(s_, lower);
  }

  virtual std::string toString() const {
    char buffer[4096];
    string s = s_.toString();
    snprintf(buffer, sizeof(buffer), "%u-mesh[%p]:%s", unsigned(Mesh::topological_dimension), mesh_, s.c_str());
    return buffer;
  }

  private:
  Simplex s_;
  Mesh *mesh_;
};

template <class Mesh>
ProtectedBall<Mesh::ambient_dimension> *makeProtectedBall(
    Mesh *m,
    const typename Mesh::Simplex& s) {
  return new PBall<Mesh>(m, s);
}

#endif

---