geometry.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_mesh_simplicial_geometry_h__)
#define __geom_mesh_simplicial_geometry_h__

#include "SimpMeshRed.h"
#include "topology.h"

#include "../simplex/geometry.h"

#include "../../../numerical/constants.h"

BEGIN_NAMESPACE_GEOM


template<class SMR>
typename SMR::Number
computeIncidentCellsAngle(typename SMR::NodeConstIterator node);




template<class SMR>
typename SMR::Number
computeDihedralAngle(typename SMR::ConstEdge edge);




template<class SMR>
typename SMR::Number
computeCosineAngle(typename SMR::FaceConstIterator face);



template<class SMR>
class IsNotSharpAngle :
  public std::unary_function<const typename SMR::NodeConstIterator&, bool> {
  // Types.
private:
  typedef std::unary_function<const typename SMR::NodeConstIterator&, bool>
  Base;

public:
  typedef typename SMR::Number Number;
  typedef typename Base::argument_type argument_type;
  typedef typename Base::result_type result_type;

private:
  // Data.
  Number _minAngle;

  // Not Implemented.
  IsNotSharpAngle();
  IsNotSharpAngle& operator=(const IsNotSharpAngle&);

public:
  
  IsNotSharpAngle(const IsNotSharpAngle& x) :
    _minAngle(x._minAngle)
  {}

  IsNotSharpAngle(const Number minAngle) :
    _minAngle(minAngle)
  {}


  result_type
  operator()(argument_type x) const
  {
    Number a = computeIncidentCellsAngle<SMR>(x);
    return _minAngle <= a && 
      a <= 2.0 * numerical::Constants<Number>::Pi() - _minAngle;
  }
};




template<class SMR>
void
computeNodeNormal(typename SMR::NodeConstIterator node, 
                  typename SMR::Vertex* normal);



template<class SMR>
inline
typename SMR::Vertex
computeNodeNormal(typename SMR::NodeConstIterator node) {
  typename SMR::Vertex normal;
  computeNodeNormal<SMR>(node, &normal);
  return normal;
}



template<class SMR>
void
computeCellNormal(typename SMR::CellConstIterator cell, 
                  typename SMR::Vertex* normal);



template<class SMR>
inline
typename SMR::Vertex
computeCellNormal(typename SMR::CellConstIterator cell) {
  typename SMR::Vertex normal;
  computeCellNormal<SMR>(cell, &normal);
  return normal;
}



template<class SMR>
void
computeFaceNormal(typename SMR::CellConstIterator cell, int i, 
                  typename SMR::Vertex* x);




template<typename T,
         template<class> class Node,
         template<class> class Cell,
         template<class,class> class Cont,
         typename OutputIterator>
void
projectAndGetSimplices(const SimpMeshRed<2,1,T,Node,Cell,Cont>& mesh,
                       OutputIterator simplices);


template<typename T,
         template<class> class Node,
         template<class> class Cell,
         template<class,class> class Cont,
         typename OutputIterator>
void
projectAndGetSimplices(const SimpMeshRed<3,2,T,Node,Cell,Cont>& mesh,
                       OutputIterator simplices);


END_NAMESPACE_GEOM

#define __geom_mesh_simplicial_geometry_ipp__
#include "geometry.ipp"
#undef __geom_mesh_simplicial_geometry_ipp__

#endif

---