SurfaceMeshMeasure.h

 
#pragma once

 
#if defined(SurfaceMeshMeasure_RECURSES)
#error Recursive header files inclusion detected in SurfaceMeshMeasure.h
#else // defined(SurfaceMeshMeasure_RECURSES)
#define SurfaceMeshMeasure_RECURSES
 
#if !defined SurfaceMeshMeasure_h
#define SurfaceMeshMeasure_h

// Inclusions
#include <vector>
#include "DGtal/kernel/CCommutativeRing.h"
#include "DGtal/shapes/SurfaceMesh.h"
 
namespace DGtal
{
  template < typename TRealPoint, typename TRealVector, typename TValue >
  struct SurfaceMeshMeasure
  {
    // ------------------------- Public Types ------------------------------
  public:
 
    typedef TRealPoint                     RealPoint;
    typedef TRealVector                    RealVector;
    typedef TValue                         Value;
    typedef SurfaceMeshMeasure< RealPoint, RealVector, Value > Self;
    // JOL: cannot check commutative ring on Tensor matrices, since it
    // is required in the concept to be constructible from the (int)
    // 0.
    // BOOST_CONCEPT_ASSERT(( concepts::CCommutativeRing< Value > ));
    typedef DGtal::SurfaceMesh< RealPoint, RealVector > SurfaceMesh;
    typedef typename SurfaceMesh::Index    Index;
    typedef typename SurfaceMesh::Size     Size;
    typedef typename SurfaceMesh::Vertex   Vertex;
    typedef typename SurfaceMesh::Edge     Edge;
    typedef typename SurfaceMesh::Face     Face;
    typedef std::vector< Value >           Values;
    typedef typename RealVector::Component Scalar;
    typedef std::pair< Face, Scalar >      WeightedFace;
    typedef std::pair< Edge, Scalar >      WeightedEdge;
    typedef std::pair< Vertex, Scalar >    WeightedVertex;
    typedef std::vector< Vertex >          Vertices;
    typedef std::vector< Edge >            Edges;
    typedef std::vector< Face >            Faces;
    typedef std::vector< WeightedVertex >  WeightedVertices;
    typedef std::vector< WeightedEdge >    WeightedEdges;
    typedef std::vector< WeightedFace >    WeightedFaces;
    static const Dimension dimension = RealPoint::dimension;
 
    // ------------------------- Standard services ------------------------------
  public:

    SurfaceMeshMeasure( ConstAlias< SurfaceMesh > aMesh = nullptr,
                        Value zero_value = Value() )
      : myMeshPtr( &aMesh ), myZero( zero_value ) {}

    const SurfaceMesh* meshPtr() const
    {
      return myMeshPtr;
    }

    const Values& kMeasures( Dimension dim ) const
    {
      return ( dim == 0 ) ? vertex_measures
        : ( (dim == 1 ) ? edge_measures : face_measures );
    }

    Values& kMeasures( Dimension dim )
    {
      return ( dim == 0 ) ? vertex_measures
        : ( (dim == 1 ) ? edge_measures : face_measures );
    }

 
    // ------------------------- Measure services ------------------------------
  public:

    Value measure() const
    {
      Value m = myZero;
      for ( auto&& lm : vertex_measures ) m += lm;
      for ( auto&& lm : edge_measures   ) m += lm;
      for ( auto&& lm : face_measures   ) m += lm;
      return m;
    }

    Value measure( const RealPoint& x, Scalar r, Face f  ) const
    {
      if ( vertex_measures.empty() && edge_measures.empty() )
        {
          WeightedFaces
            faces = myMeshPtr->computeFacesInclusionsInBall( r, f, x );
          return faceMeasure( faces );
        }
      else
        {
          std::tuple< Vertices, WeightedEdges, WeightedFaces >
            wcells = myMeshPtr->computeCellsInclusionsInBall( r, f, x );
          Value m = vertexMeasure( std::get< 0 >( wcells ) );
          m      += edgeMeasure  ( std::get< 1 >( wcells ) );
          m      += faceMeasure  ( std::get< 2 >( wcells ) );
          return m;
        }
    }

    Value vertexMeasure( Vertex v ) const
    {
      return v < vertex_measures.size() ? vertex_measures[ v ] : Value();
    }

    Value vertexMeasure( const Vertices& vertices ) const
    {
      Value m = myZero;
      if ( vertex_measures.empty() ) return m;
      for ( auto&& v : vertices )  m += vertex_measures[ v ];
      return m;
    }

    Value vertexMeasure( const WeightedVertices& wvertices ) const
    {
      Value m = myZero;
      if ( vertex_measures.empty() ) return m;
      for ( auto&& v : wvertices )  m += vertex_measures[ v.first ] * v.second;
      return m;
    }

    Value edgeMeasure( Edge e ) const
    {
      return e < edge_measures.size() ? edge_measures[ e ] : Value();
    }

    Value edgeMeasure( const Edges& edges ) const
    {
      Value m = myZero;
      if ( edge_measures.empty() ) return m;
      for ( auto&& e : edges )  m += edge_measures[ e ];
      return m;
    }

    Value edgeMeasure( const WeightedEdges& wedges ) const
    {
      Value m = myZero;
      if ( edge_measures.empty() ) return m;
      for ( auto&& e : wedges )  m += edge_measures[ e.first ] * e.second;
      return m;
    }

    Value faceMeasure( Face f ) const
    {
      return f < face_measures.size() ? face_measures[ f ] : Value();
    }

    Value faceMeasure( const Faces& faces ) const
    {
      Value m = myZero;
      if ( face_measures.empty() ) return m;
      for ( auto&& v : faces )  m += face_measures[ v ];
      return m;
    }

    Value faceMeasure( const WeightedFaces& wfaces ) const
    {
      Value m = myZero;
      if ( face_measures.empty() ) return m;
      for ( auto&& v : wfaces )  m += face_measures[ v.first ] * v.second;
      return m;
    }

 
    // ------------------------- Public Data ------------------------------
  public:
    Values vertex_measures;
    Values edge_measures;
    Values face_measures;
 
    // ------------------------- Protected Data ------------------------------
  protected:
    const SurfaceMesh* myMeshPtr;
    Value myZero;
  };
 
 
} // namespace DGtal

// Includes inline functions.
//                                                                           //
 
#endif // !defined SurfaceMeshMeasure_h
 
#undef SurfaceMeshMeasure_RECURSES
#endif // else defined(SurfaceMeshMeasure_RECURSES)