ATu0v1.h

 
#pragma once
 
#if defined(ATu0v1_RECURSES)
#error Recursive header files inclusion detected in ATu0v1.h
#else // defined(ATu0v1_RECURSES)
#define ATu0v1_RECURSES
 
#if !defined ATu0v1_h
#define ATu0v1_h
 
// Inclusions
#include <iostream>
// always include EigenSupport.h before any other Eigen headers
#include "DGtal/math/linalg/EigenSupport.h"
#include "DGtal/base/Common.h"
#include "DGtal/dec/DiscreteExteriorCalculus.h"
#include "DGtal/dec/DiscreteExteriorCalculusSolver.h"
#include "DGtal/dec/DiscreteExteriorCalculusFactory.h"
#include "DECImageHelpers.h"
 
 
namespace DGtal
{
 
  // template class ATu0v1
  template < typename TKSpace,
             typename TLinearAlgebra = EigenLinearAlgebraBackend >
  struct ATu0v1 : public DECImage2D<TKSpace, TLinearAlgebra>
  {
    typedef TKSpace                             KSpace;
    typedef TLinearAlgebra                      LinearAlgebra;
    typedef DECImage2D<TKSpace, TLinearAlgebra> Base;
    using typename Base::Space;
    using typename Base::Point;
    using typename Base::RealVector;
    using typename Base::Scalar;
    using typename Base::SCell;
    using typename Base::Domain;
    using typename Base::Calculus;
    using typename Base::Index;
    using typename Base::PrimalForm0;
    using typename Base::PrimalForm1;
    using typename Base::PrimalForm2;
    using typename Base::PrimalIdentity0;
    using typename Base::PrimalIdentity1;
    using typename Base::PrimalIdentity2;
    using typename Base::PrimalDerivative0;
    using typename Base::PrimalDerivative1;
    using typename Base::DualDerivative0;
    using typename Base::DualDerivative1;
    using typename Base::PrimalHodge0;
    using typename Base::PrimalHodge1;
    using typename Base::PrimalHodge2;
    using typename Base::DualHodge0;
    using typename Base::DualHodge1;
    using typename Base::DualHodge2;
    using Base::calculus;
    using Base::verbose;
    using Base::D0;
    using Base::D1;
    using Base::dual_D0;
    using Base::dual_D1;
    using Base::primal_h0;
    using Base::primal_h1;
    using Base::primal_h2;
    using Base::dual_h0;
    using Base::dual_h1;
    using Base::dual_h2;
 
    typedef typename LinearAlgebra::SolverSimplicialLLT    LinearAlgebraSolver;
    typedef DiscreteExteriorCalculusSolver<Calculus, LinearAlgebraSolver, 0, PRIMAL, 0, PRIMAL> 
                                                           SolverU;
    typedef DiscreteExteriorCalculusSolver<Calculus, LinearAlgebraSolver, 1, PRIMAL, 1, PRIMAL> 
                                                           SolverV;
 
    BOOST_STATIC_ASSERT(( KSpace::dimension == 2 ));
 
    // ----------------------- Standard services ------------------------------
  public:
 
    ~ATu0v1() = default;
 
    ATu0v1( int _verbose = 1 );
    
    void init( Clone<KSpace> K );
 
    ATu0v1 ( const ATu0v1 & other ) = delete;
 
    ATu0v1 ( ATu0v1 && other ) = delete;
 
    ATu0v1 & operator= ( const ATu0v1 & other ) = delete;
 
    ATu0v1 & operator= ( ATu0v1 && other ) = delete;
 
    template <typename Image, typename Function >
    void addInput( const Image& image,
                   const Function& f,
                   bool perfect_data = false );
 
    void setUFromInput();
 
    void setAlpha( Scalar _alpha );
 
    void setAlpha( Scalar _alpha, const PrimalForm0& m );
 
    void setLambda( Scalar _lambda );
 
    void setEpsilon( Scalar _epsilon );
 
    Scalar computeSNR() const;
    
    Scalar getAlpha() const { return alpha; }
 
    Scalar getLambda() const { return lambda; }
 
    Scalar getEpsilon() const { return epsilon; }
 
    const PrimalForm0& getG( int i ) const { return g0.at( i ); }
 
    const PrimalForm0& getU( int i ) const { return u0.at( i ); }
 
    const PrimalForm1& getV() const { return v1; }
 
    unsigned int size0() const { return alpha_Id0.myContainer.columns(); }
 
    unsigned int size1() const { return v1.myContainer.rows(); }
 
    // ----------------------- Solver --------------------------------------
  public:
    
    bool solveU();
 
    bool solveV();
 
    Scalar computeVariation();
 
    Scalar checkV();
 
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
 
    // ------------------------- Public Datas ------------------------------
  public:
 
    Scalar delta_v_l1;
    Scalar delta_v_l2;
    Scalar delta_v_loo;
 
    PrimalIdentity1       L1;
 
    // ------------------------- Protected Datas ------------------------------
  protected:
 
    std::vector< PrimalForm0 > g0;
    std::vector< PrimalForm0 > i0;
    std::vector< PrimalForm0 > u0;
    PrimalForm1 v1;
    PrimalForm1 former_v1;
    double alpha;
    double lambda;
    double epsilon;
 
    SolverU solver_u;
    SolverV solver_v;
 
    PrimalIdentity0 alpha_Id0;
    std::vector< PrimalForm0 > alpha_g0;
    PrimalIdentity1       l_L1;
    PrimalForm1           l_1_over_4;
    PrimalIdentity1       left_V1;
    PrimalForm1           l_1_over_4e;
 
    // ------------------------- Private Datas --------------------------------
  private:
 
    // ------------------------- Hidden services ------------------------------
  protected:
 
    // ------------------------- Internals ------------------------------------
  private:
 
  }; // end of class ATu0v1
 
 
  template <typename TKSpace, typename TLinearAlgebra>
  std::ostream&
  operator<< ( std::ostream & out, const ATu0v1<TKSpace, TLinearAlgebra> & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
//#include "DGtal/dec/ATu0v1.ih"
#include "ATu0v1.ih"
 
//                                                                           //
 
#endif // !defined ATu0v1_h
 
#undef ATu0v1_RECURSES
#endif // else defined(ATu0v1_RECURSES)