SimplexWithFreeVertex.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_SimplexWithFreeVertex_h__)
#define __geom_SimplexWithFreeVertex_h__

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

#ifdef DEBUG_SimplexWithFreeVertex
#ifndef DEBUG_Simplex
#define DEBUG_Simplex
#endif
#endif

#include "Simplex.h"

BEGIN_NAMESPACE_GEOM


template<template<int,typename> class QF,
         int N,
         typename T = double>
class SimplexWithFreeVertex {
private:

  //
  // Private types.
  //

  typedef QF<N,T> QualityFunction;

public:

  //
  // Public types.
  //

  typedef T Number;

  typedef typename QualityFunction::Vertex Vertex;

  typedef Simplex<N,Vertex,Number> Simplex;

  typedef typename Simplex::Face Face;

private:

  // The simplex of vertices.
  Simplex _simplex;
  // The quality function.
  QualityFunction _qualityFunction;

public:

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

  SimplexWithFreeVertex() :
    _simplex(),
    _qualityFunction()
  {}

  SimplexWithFreeVertex(const Face& face) :
    _simplex(),
    _qualityFunction() {
    set(face);
  }

  SimplexWithFreeVertex(const SimplexWithFreeVertex& other) :
    _simplex(other._simplex),
    _qualityFunction(other._qualityFunction)
  {}

  SimplexWithFreeVertex& 
  operator=(const SimplexWithFreeVertex& other) {
    if (&other != this) {
      _simplex = other._simplex;
      _qualityFunction = other._qualityFunction;
    }
    return *this;
  }
  
  ~SimplexWithFreeVertex()
  {}

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

  Vertex
  getFreeVertex() const {
    return _simplex[0];
  }

  void
  computeBBox(BBox<N,T>* bb) const {
    _simplex.computeBBox(bb);
  }

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

  void
  set(const Face& face) {
    for (int i = 0; i != N; ++i) {
      _simplex[i+1] = face[i];
    }
  }

  void
  setFunction(const Vertex& v) {
    _simplex[0] = v;
    _qualityFunction.setFunction(_simplex);
  }

  void
  set(const Vertex& v) {
    _simplex[0] = v;
    _qualityFunction.set(_simplex);
  }

  // @}
  //--------------------------------------------------------------------------

  Number
  operator()() const {
    return _qualityFunction();
  }

  void
  computeGradient(Vertex* gradient) const {
    _qualityFunction.computeGradient(gradient);
  }

  Number
  operator()(const Number minimumDeterminant) const {
    return _qualityFunction(minimumDeterminant);
  }

  void
  computeGradient(const Number minimumDeterminant, Vertex* gradient) const {
    _qualityFunction.computeGradient(minimumDeterminant, gradient);
  }

  Number
  getDeterminant() const {
    return _qualityFunction.getDeterminant();
  }

  Number
  computeContent() const {
    return _qualityFunction.computeContent();
  }

  void
  computeGradientOfContent(Vertex* gradient) const {
    _qualityFunction.computeGradientContent(gradient);
  }

  // @}
};

END_NAMESPACE_GEOM

#endif

---