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)