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/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(( CCellularGridSpaceND< TKSpace > ));
    BOOST_CONCEPT_ASSERT(( CImplicitFunctionDiff1< TImplicitFunctionDiff1 > ));
    BOOST_CONCEPT_ASSERT(( 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( const KSpace & K, const ImplicitFunctionDiff1 & f, 
               const 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 >
  struct ImplicitFunctionDiff1LinearCellEmbedderGradientMap
    : public ImplicitFunctionDiff1LinearCellEmbedder< TKSpace, 
                                                      TImplicitFunctionDiff1,
                                                      TEmbedder>
  {
    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)