ImplicitFunctionDiff1LinearCellEmbedder.h

 
#pragma once
 
#if defined(ImplicitFunctionDiff1LinearCellEmbedder_RECURSES)
#error Recursive header files inclusion detected in ImplicitFunctionDiff1LinearCellEmbedder.h
#else // defined(ImplicitFunctionDiff1LinearCellEmbedder_RECURSES)
#define ImplicitFunctionDiff1LinearCellEmbedder_RECURSES
 
#if !defined ImplicitFunctionDiff1LinearCellEmbedder_h
#define ImplicitFunctionDiff1LinearCellEmbedder_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/kernel/NumberTraits.h"
#include "DGtal/kernel/CPointEmbedder.h"
#include "DGtal/topology/CCellularGridSpaceND.h"
#include "DGtal/shapes/implicit/CImplicitFunction.h"
#include "DGtal/shapes/implicit/CImplicitFunctionDiff1.h"
 
namespace DGtal
{
 
  template < typename TKSpace,
             typename TImplicitFunctionDiff1,
             typename TEmbedder >
  class ImplicitFunctionDiff1LinearCellEmbedderGradientMap;
 
 
  template < typename TKSpace,
             typename TImplicitFunctionDiff1,
             typename TEmbedder >
  class ImplicitFunctionDiff1LinearCellEmbedder
  {
    BOOST_CONCEPT_ASSERT(( concepts::CCellularGridSpaceND< TKSpace > ));
    BOOST_CONCEPT_ASSERT(( concepts::CImplicitFunctionDiff1< TImplicitFunctionDiff1 > ));
    BOOST_CONCEPT_ASSERT(( concepts::CPointEmbedder< TEmbedder > ));
 
  public:
    typedef TKSpace KSpace;
    typedef TImplicitFunctionDiff1 ImplicitFunctionDiff1;
    typedef TEmbedder Embedder;
    typedef typename KSpace::Cell Cell;
    typedef typename KSpace::SCell SCell;
    typedef typename KSpace::Space Space;
    typedef typename Space::Point Point;
    typedef typename Space::RealPoint RealPoint;
    typedef typename Space::RealVector RealVector;
    typedef typename ImplicitFunctionDiff1::Value ImplicitFctValue;
    typedef Cell Argument;
    typedef RealPoint Value;
    typedef ImplicitFunctionDiff1LinearCellEmbedderGradientMap
    < KSpace, ImplicitFunctionDiff1, Embedder > GradientMap;
    
    ImplicitFunctionDiff1LinearCellEmbedder();
    
    ~ImplicitFunctionDiff1LinearCellEmbedder();
 
    ImplicitFunctionDiff1LinearCellEmbedder( const ImplicitFunctionDiff1LinearCellEmbedder & other );
 
    ImplicitFunctionDiff1LinearCellEmbedder & 
    operator= ( const ImplicitFunctionDiff1LinearCellEmbedder & other );
 
    void init( ConstAlias<KSpace> K, ConstAlias<ImplicitFunctionDiff1> f, 
               ConstAlias<Embedder> e );
 
    // ----------------------- Interface --------------------------------------
  public:
 
    GradientMap gradientMap() const;
 
    RealPoint embed( const Point & p ) const;
 
    RealPoint embedCell( const Cell & cell ) const;
 
    RealPoint embedSCell( const SCell & scell ) const;
 
    RealPoint operator()( const Cell & cell ) const;
 
    void embed( const Point & p, RealPoint & x, RealVector & grad ) const;
 
    void embedCell( const Cell & cell, 
                    RealPoint & x, RealVector & grad ) const;
 
    void embedSCell( const SCell & scell, 
                     RealPoint & x, RealVector & grad ) const;
    
    // ----------------------- Interface --------------------------------------
  public:
    
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
   
    const KSpace* myPtrK;
    const ImplicitFunctionDiff1* myPtrFct;
    const Embedder* myPtrEmbedder;
   
  }; // end of class ImplicitFunctionDiff1LinearCellEmbedder
 
  template < typename TKSpace,
             typename TImplicitFunctionDiff1,
             typename TEmbedder >
  class ImplicitFunctionDiff1LinearCellEmbedderGradientMap
    : public ImplicitFunctionDiff1LinearCellEmbedder< TKSpace, 
                                                      TImplicitFunctionDiff1,
                                                      TEmbedder>
  {
  public:
    typedef ImplicitFunctionDiff1LinearCellEmbedderGradientMap
    < TKSpace, TImplicitFunctionDiff1, TEmbedder> Self;
    typedef ImplicitFunctionDiff1LinearCellEmbedder
    < TKSpace, TImplicitFunctionDiff1, TEmbedder> Base;
    typedef typename Base::Cell Cell;
    typedef typename Base::RealPoint RealPoint;
    typedef typename Base::RealVector RealVector;
    typedef Cell Argument;
    typedef RealVector Value;
    using Base::myPtrFct;
 
    inline
    ImplicitFunctionDiff1LinearCellEmbedderGradientMap
    ( const Base & other )
      : Base( other )
    {}
 
    inline
    Self & operator=( const Base & other )
    {
      Base::operator=( other );
      return *this;
    }
 
    inline
    Value operator()( const Argument & arg ) const
    {
      RealPoint x = Base::operator()( arg );
      return myPtrFct->gradient( x );
    }
  };
 
  template < typename TKSpace, typename TImplicitFunctionDiff1, typename TEmbedder >
  std::ostream&
  operator<< ( std::ostream & out, 
               const ImplicitFunctionDiff1LinearCellEmbedder<TKSpace, TImplicitFunctionDiff1, TEmbedder> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/shapes/implicit/ImplicitFunctionDiff1LinearCellEmbedder.ih"
 
//                                                                           //
 
#endif // !defined ImplicitFunctionDiff1LinearCellEmbedder_h
 
#undef ImplicitFunctionDiff1LinearCellEmbedder_RECURSES
#endif // else defined(ImplicitFunctionDiff1LinearCellEmbedder_RECURSES)