ComplexWithFreeVertex.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_ComplexWithFreeVertex_h__)
#define __geom_ComplexWithFreeVertex_h__

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

#include "SimplexWithFreeVertex.h"
#include "SimplexModDet.h"

#include <vector>
#include <iostream>

#include <cassert>

BEGIN_NAMESPACE_GEOM



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

  //
  // Private types.
  //

  typedef SimplexWithFreeVertex<QF,N,T> SWFV;
  typedef std::vector<SWFV> SimplexContainer;
  typedef typename SimplexContainer::iterator SimplexIterator;
  typedef typename SimplexContainer::const_iterator SimplexConstIterator;

public:

  //
  // Public types.
  //

  typedef T Number;

  typedef typename SWFV::Vertex Vertex;

  typedef typename SWFV::Face Face;

private:

  //
  // Data
  //

  SimplexContainer _simplices;

  //
  // Not implemented.
  //

  // Copy constructor not implemented.
  ComplexWithFreeVertex(const ComplexWithFreeVertex&);

  // Assignment operator not implemented.
  ComplexWithFreeVertex& 
  operator=(const ComplexWithFreeVertex&);
  
public:

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

  ComplexWithFreeVertex()
  {}

  template<typename FaceIterator>
  ComplexWithFreeVertex(FaceIterator beginning, FaceIterator end) {
    set(beginning, end);
  }

  ~ComplexWithFreeVertex()
  {}

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

  Vertex
  getFreeVertex() const {
    assert(! _simplices.empty());
    return _simplices[0].getFreeVertex();
  }

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

  template<typename FaceIterator>
  void
  set(FaceIterator begin, FaceIterator end);

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

  void
  computeBBox(const Vertex& v, BBox<N,T>* bb) {
    set(v);
    computeBBox(bb);
  }

  Number
  computeContent(const Vertex& v);

  void
  computeGradientOfContent(const Vertex& v, Vertex* gradient);

  Number
  computeNorm2(const Vertex& v);

  void
  computeGradientOfNorm2(const Vertex& v, Vertex* gradient);

  Number
  computeNorm2Modified(const Vertex& v);

  void
  computeGradientOfNorm2Modified(const Vertex& v, Vertex* gradient);


protected:


  void
  set(const Vertex& v);

private:

  // Return the minimum Jacobian determinant.
  Number
  computeMinDeterminant() const;

  // Calculate the bounding box for the complex.
  void
  computeBBox(BBox<N,T>* bb) const;

  // Return the content.
  // The free vertex must be set before calling this function.
  Number
  computeContent() const;

  // Calculate the gradient of the content.
  // The free vertex must be set before calling this function.
  void
  computeGradientOfContent(Vertex* gradient) const;

  // Return the 2-norm of the quality metric.
  // The free vertex must be set before calling this function.
  Number
  computeNorm2() const;

  // Calculate the gradient of the 2-norm of the quality metric.
  // The free vertex must be set before calling this function.
  void
  computeGradientOfNorm2(Vertex* gradient) const;

  // Return the 2-norm of the modified quality metric.
  // The free vertex must be set before calling this function.
  Number
  computeNorm2Modified(Number minDetermintant) const;

  // Calculate the gradient of the 2-norm of the modified quality metric.
  // The free vertex must be set before calling this function.
  void
  computeGradientOfNorm2Modified(Number minDetermintant, Vertex* gradient) 
    const;
};



template<class Complex>
class ComplexContentConstraint :
  public std::unary_function<typename Complex::Vertex, 
                             typename Complex::Number>
{
private:

  typedef std::unary_function<typename Complex::Vertex, 
                              typename Complex::Number> base_type;

public:

  typedef typename base_type::argument_type argument_type;
  typedef typename base_type::result_type result_type;

private:

  mutable Complex& _sc;

  // The content of the complex for the initial position of the free vertex.
  result_type _initialContent;

  // Default constructor not implemented.
  ComplexContentConstraint();

  // Assignment operator not implemented.
  ComplexContentConstraint&
  operator=(const ComplexContentConstraint&);

public:

  ComplexContentConstraint(Complex& sc) :
    _sc(sc)
  {}

  ComplexContentConstraint(const ComplexContentConstraint& other) :
    _sc(other._sc)
  {}

  void
  initialize(const argument_type& x) {
    _initialContent = _sc.computeContent(x);
  }

  result_type
  operator()(const argument_type& x) const {
#ifdef DEBUG_ComplexWithFreeVertex
    assert(_initialContent != 0);
#endif
    return (_sc.computeContent(x) - _initialContent) / _initialContent;
  }

  void
  gradient(const argument_type& x, argument_type& grad) const {
#ifdef DEBUG_ComplexWithFreeVertex
    assert(_initialContent != 0);
#endif
    _sc.computeGradientOfContent(x, &grad);
    grad /= _initialContent;
  }
};


template<class Complex>
class ComplexNorm2 :
  public std::unary_function<typename Complex::Vertex, 
                             typename Complex::Number>
{
private:

  typedef std::unary_function<typename Complex::Vertex, 
                              typename Complex::Number> Base;

public:

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

private:

  mutable Complex& _sc;

  // Default constructor not implemented.
  ComplexNorm2();

  // Assignment operator not implemented.
  ComplexNorm2&
  operator=(const ComplexNorm2&);

public:

  ComplexNorm2(Complex& sc) :
    _sc(sc)
  {}

  ComplexNorm2(const ComplexNorm2& other) :
    _sc(other._sc)
  {}

  result_type
  operator()(const argument_type& x) const {
    return _sc.computeNorm2(x);
  }

  void
  gradient(const argument_type& x, argument_type& grad) const {
    _sc.computeGradientOfNorm2(x, &grad);
  }
};



template<class Complex>
class ComplexNorm2Mod :
  public std::unary_function<typename Complex::Vertex, 
                             typename Complex::Number>
{
private:

  typedef std::unary_function<typename Complex::Vertex, 
                              typename Complex::Number> Base;

public:

  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

private:

  mutable Complex& _sc;

  // Default constructor not implemented.
  ComplexNorm2Mod();

  // Assignment operator not implemented.
  ComplexNorm2Mod&
  operator=(const ComplexNorm2Mod&);

public:

  ComplexNorm2Mod(Complex& sc) :
    _sc(sc)
  {}

  ComplexNorm2Mod(const ComplexNorm2Mod& x) :
    _sc(x._sc)
  {}

  result_type
  operator()(const argument_type& x) const {
    return _sc.computeNorm2Modified(x);
  }

  void
  gradient(const argument_type& x, argument_type& grad) const {
    _sc.computeGradientOfNorm2Modified(x, &grad);
  }
};


END_NAMESPACE_GEOM

#define __geom_ComplexWithFreeVertex_ipp__
#include "ComplexWithFreeVertex.ipp"
#undef __geom_ComplexWithFreeVertex_ipp__

#endif

---