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)