ATu2v0.h

#pragma once

#if defined(ATu2v0_RECURSES)
#error Recursive header files inclusion detected in ATu2v0.h
#else // defined(ATu2v0_RECURSES)

#define ATu2v0_RECURSES

#if !defined ATu2v0_h

#define ATu2v0_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 ATu2v0
  template < typename TKSpace,
             typename TLinearAlgebra = EigenLinearAlgebraBackend >
  struct ATu2v0 : 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::PrimalAntiderivative1;
    using typename Base::PrimalAntiderivative2;
    using typename Base::DualAntiderivative1;
    using typename Base::DualAntiderivative2;
    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, 2, PRIMAL, 2, PRIMAL> 
                                                           SolverU;
    typedef DiscreteExteriorCalculusSolver<Calculus, LinearAlgebraSolver, 0, PRIMAL, 0, PRIMAL> 
                                                           SolverV;

    BOOST_STATIC_ASSERT(( KSpace::dimension == 2 ));

    // ----------------------- Standard services ------------------------------
  public:

    ~ATu2v0() = default;

    ATu2v0( int _verbose = 1 );
    
    void init( Clone<KSpace> K );

    ATu2v0 ( const ATu2v0 & other ) = delete;

    ATu2v0 ( ATu2v0 && other ) = delete;

    ATu2v0 & operator= ( const ATu2v0 & other ) = delete;

    ATu2v0 & operator= ( ATu2v0 && other ) = delete;

    template <typename Image, typename Function>
    void addInput( const Image& image,
                   const Function& f,
                   bool perfect_data = false );

    void setMetricAverage( bool average );
    
    void setUFromInput();

    void setUFromInputAndMask();

    void setAlpha( Scalar _alpha );

    void setAlpha( Scalar _alpha, const PrimalForm2& 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 PrimalForm2& getG( int i ) const { return g2.at( i ); }

    const PrimalForm2& getU( int i ) const { return u2.at( i ); }

    const PrimalForm0& getV() const { return v0; }

    unsigned int size0() const { return v0.myContainer.rows(); }

    // /// @return the size of a 1-form vector
    // 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;

    PrimalDerivative0     M01;
    PrimalDerivative1     M12;
    PrimalAntiderivative2 primal_AD2;

    // ------------------------- Protected Datas ------------------------------
  protected:

    std::vector< PrimalForm2 > g2;
    std::vector< PrimalForm2 > i2;
    std::vector< PrimalForm2 > u2;
    PrimalForm0 v0;
    PrimalForm0 former_v0;
    double alpha;
    double lambda;
    double epsilon;

    SolverU solver_u;
    SolverV solver_v;

    PrimalIdentity2 alpha_Id2;
    std::vector< PrimalForm2 > alpha_g2;
    PrimalIdentity0       left_V0;
    PrimalForm0           l_1_over_4;
    PrimalForm0           l_1_over_4e;
    PrimalIdentity0       l_1_over_4e_Id0;    

    bool metric_average;
    
    // ------------------------- Private Datas --------------------------------
  private:

    // ------------------------- Hidden services ------------------------------
  protected:

    // ------------------------- Internals ------------------------------------
  private:

  }; // end of class ATu2v0


  template <typename TKSpace, typename TLinearAlgebra>
  std::ostream&
  operator<< ( std::ostream & out, const ATu2v0<TKSpace, TLinearAlgebra> & object );

} // namespace DGtal


// Includes inline functions.
//#include "DGtal/dec/ATu2v0.ih"
#include "ATu2v0.ih"

//                                                                           //

#endif // !defined ATu2v0_h

#undef ATu2v0_RECURSES
#endif // else defined(ATu2v0_RECURSES)