Simplex.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_Simplex_h__)
#define __geom_Simplex_h__

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

#include "../../defs.h"

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

#include "../../../ads/array/FixedArray.h"

#include <cassert>

BEGIN_NAMESPACE_GEOM


template<int N, typename V, typename T = double>
class Simplex {
  //
  // Public types.
  //

public:

  typedef V Vertex;

  typedef T Number;

  typedef ads::FixedArray<N+1,Vertex> VertexContainer;

  typedef typename VertexContainer::value_type Value;

  typedef typename VertexContainer::iterator Iterator;

  typedef typename VertexContainer::const_iterator ConstIterator;
  
  typedef typename VertexContainer::reference Reference;

  typedef typename VertexContainer::const_reference ConstReference;

  typedef typename VertexContainer::parameter_type Parameter;

  typedef Simplex<N-1,V,T> Face;

private:

  //
  // Member data.
  //

  VertexContainer _vertices;

public:

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

  Simplex() :
    _vertices()
  {}

  Simplex(const Simplex& other) :
    _vertices(other._vertices)
  {}

  explicit
  Simplex(const VertexContainer& vertices) :
    _vertices(vertices)
  {}

  void
  build(const VertexContainer& vertices) {
    _vertices = vertices;
  }

  explicit
  Simplex(Parameter v) :
    _vertices(v) {
    LOKI_STATIC_CHECK(N == 0, N_is_0);
  }

  void
  build(Parameter v) {
    LOKI_STATIC_CHECK(N == 0, N_is_0);
    _vertices[0] = v;
  }

  Simplex(Parameter v0, Parameter v1) :
    _vertices(v0, v1) {
    LOKI_STATIC_CHECK(N == 1, N_is_1);
  }

  void
  build(Parameter v0, Parameter v1) {
    LOKI_STATIC_CHECK(N == 1, N_is_1);
    _vertices[0] = v0;
    _vertices[1] = v1;
  }

  Simplex(Parameter v0, Parameter v1, Parameter v2) :
    _vertices(v0, v1, v2) {
    LOKI_STATIC_CHECK(N == 2, N_is_2);
  }

  void
  build(Parameter v0, Parameter v1, Parameter v2) {
    LOKI_STATIC_CHECK(N == 2, N_is_2);
    _vertices[0] = v0;
    _vertices[1] = v1;
    _vertices[2] = v2;
  }

  Simplex(Parameter v0, Parameter v1, Parameter v2, Parameter v3) :
    _vertices(v0, v1, v2, v3) {
    LOKI_STATIC_CHECK(N == 3, N_is_3);
  }

  void
  build(Parameter v0, Parameter v1, Parameter v2, Parameter v3) {
    LOKI_STATIC_CHECK(N == 3, N_is_3);
    _vertices[0] = v0;
    _vertices[1] = v1;
    _vertices[2] = v2;
    _vertices[3] = v3;
  }

  template<typename VertRAIter, typename IndSimp>
  Simplex(VertRAIter vertices, const IndSimp& indexed_simplex) :
    _vertices() {
    for (int n = 0; n != N + 1; ++n) {
      _vertices[n] = vertices[indexed_simplex[n]];
    }
  }

  template<typename VertRAIter, typename IndSimp>
  void
  build(VertRAIter vertices, const IndSimp& indexed_simplex) {
    for (int n = 0; n != N + 1; ++n) {
      _vertices[n] = vertices[indexed_simplex[n]];
    }
  }

  Simplex& 
  operator=(const Simplex& other) {
    if (&other != this) {
      _vertices = other._vertices;
    }
    return *this;
  }
  
  ~Simplex()
  {}

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

  ConstIterator
  begin() const {
    return _vertices.begin();
  }
  
  ConstIterator
  end() const {
    return _vertices.end();
  }

  int
  size() const {
    return N + 1;
  }

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

  const VertexContainer&
  getVertices() const {
    return _vertices;
  }

  Parameter
  operator[](const int n) const {
    return _vertices[n];
  }

  ConstIterator
  getBeginning() const {
    return _vertices.begin();
  }
  
  ConstIterator
  getEnd() const {
    return _vertices.end();
  }

  int
  getSize() const {
    return N + 1;
  }

  template<typename Comparable>
  bool
  hasVertex(const Comparable& v) const;
  

  template<typename Comparable>
  bool
  hasVertex(const Comparable& v, int* n) const;
  

  template<int M>
  bool
  hasFace(const Simplex<M,V,T>& f) const;
  
  template<typename Comparable>
  int
  getVertexIndex(const Comparable& v) const;


  Face
  getFace(const int n) const {
    Face f;
    getFace(n, &f);
    return f;
  }


  void
  getFace(const int n, Face* f) const;

  void
  computeBBox(BBox<N,Number>* bb) const {
    bb->bound(begin(), end());
  }

  void
  computeCentroid(Vertex* centroid) const {
    *centroid = Number(0);
    for (int n = 0; n != N+1; ++n) {
      *centroid += _vertices[n];
    }
    *centroid /= Number(N + 1);
  }

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

  Iterator
  begin() {
    return _vertices.begin();
  }
  
  Iterator
  end() {
    return _vertices.end();
  }
  
  //--------------------------------------------------------------------------

  // CONTINUE: I think I should remove this.
#if 0
  VertexContainer&
  vertices() {
    return _vertices;
  }
#endif

  Reference
  operator[](const int n) {
    return _vertices[n];
  }
  
  Iterator
  getBeginning() {
    return _vertices.begin();
  }
  
  Iterator
  getEnd() {
    return _vertices.end();
  }
  
  void
  set(const VertexContainer& vertices) {
    _vertices = vertices;
  }

  void
  setEach(Parameter value) {
    _vertices = value;
  }

  void
  negate() {
    if (N > 0) {
      std::swap(_vertices[0], _vertices[1]);
    }
  }

};

//
// Equality Tests
//


template<int N, typename V, typename T>
bool
operator==(const Simplex<N,V,T>& x, const Simplex<N,V,T>& y) {
  return (x.getVertices() == y.getVertices());
}


template<int N, typename V, typename T>
bool
operator!=(const Simplex<N,V,T>& x, const Simplex<N,V,T>& y) {
  return !(x == y);
}


template<typename V, typename T>
bool
haveSameOrientation(const Simplex<0,V,T>& x, const Simplex<0,V,T>& y) {
#ifdef DEBUG_geom
  assert(x[0] == y[0]);
#endif
  return true;
}


template<typename V, typename T>
bool
haveSameOrientation(const Simplex<1,V,T>& x, const Simplex<1,V,T>& y) {
#ifdef DEBUG_geom
  assert(x.hasVertex(y[0]) && x.hasVertex(y[1]));
#endif
  return x[0] == y[0];
}


template<typename V, typename T>
bool
haveSameOrientation(const Simplex<2,V,T>& x, const Simplex<2,V,T>& y) {
#ifdef DEBUG_geom
  assert(x.hasVertex(y[0]) && x.hasVertex(y[1]) && x.hasVertex(y[2]));
#endif
  if (x[0] == y[0]) {
    return x[1] == y[1];
  }
  else if (x[0] == y[1]) {
    return x[1] == y[2];
  }
  // else x[0] == y[2]
  return x[1] == y[0];
}


//
// File I/O
//


template<int N, typename V, typename T>
inline
std::ostream&
operator<<(std::ostream& out, const Simplex<N,V,T>& x) {
  return out << x.getVertices();
}


template<int N, typename V, typename T>
inline
std::istream&
operator>>(std::istream& in, Simplex<N,V,T>& x) {
  for (int n = 0; n != N + 1; ++n) {
    in >> x[n];
  }
  return in;
}

END_NAMESPACE_GEOM

#define __geom_Simplex_ipp__
#include "Simplex.ipp"
#undef __geom_Simplex_ipp__

#endif

---