Aim: This class solves Ambrosio-Tortorelli functional on a two-dimensional digital space (a 2D grid or 2D digital surface) for a piecewise smooth scalar/vector function u represented as one/several 2-form(s) and a discontinuity function v represented as a 0-form. The 2-form(s) u is a regularized approximation of an input vector data g, while v represents the set of discontinuities of u. The norm chosen for u is the \( l_2 \)-norm. More...

#include <DGtal/dec/ATSolver2D.h>

Public Types
enum	CellOutputPolicy { Average , Minimum , Maximum }

typedef TKSpace	KSpace

typedef TLinearAlgebra	LinearAlgebra

typedef ATSolver2D< KSpace, LinearAlgebra >	Self

typedef KSpace::Space	Space

typedef Space::RealVector	RealVector

typedef RealVector::Component	Scalar

typedef KSpace::SCell	SCell

typedef KSpace::Cell	Cell

typedef KSpace::Surfel	Surfel

typedef HyperRectDomain< Space >	Domain

typedef DiscreteExteriorCalculus< 2, dimension, LinearAlgebra >	Calculus

typedef KSpace::template SurfelMap< double >::Type	SmallestEpsilonMap

typedef Calculus::Index	Index

typedef Calculus::PrimalForm0	PrimalForm0

typedef Calculus::PrimalForm1	PrimalForm1

typedef Calculus::PrimalForm2	PrimalForm2

typedef Calculus::PrimalIdentity0	PrimalIdentity0

typedef Calculus::PrimalIdentity1	PrimalIdentity1

typedef Calculus::PrimalIdentity2	PrimalIdentity2

typedef Calculus::PrimalDerivative0	PrimalDerivative0

typedef Calculus::PrimalDerivative1	PrimalDerivative1

typedef Calculus::PrimalAntiderivative1	PrimalAntiderivative1

typedef Calculus::PrimalAntiderivative2	PrimalAntiderivative2

typedef Calculus::PrimalHodge0	PrimalHodge0

typedef Calculus::PrimalHodge1	PrimalHodge1

typedef Calculus::PrimalHodge2	PrimalHodge2

typedef KSpace::template SurfelMap< Index >::Type	Surfel2IndexMap

typedef EigenLinearAlgebraBackend::SolverSimplicialLDLT	LinearAlgebraSolver

typedef DiscreteExteriorCalculusSolver< Calculus, LinearAlgebraSolver, 2, PRIMAL, 2, PRIMAL >	SolverU2

typedef DiscreteExteriorCalculusSolver< Calculus, LinearAlgebraSolver, 0, PRIMAL, 0, PRIMAL >	SolverV0

Public Member Functions
Standard services
	ATSolver2D (ConstAlias< Calculus > aCalculus, int aVerbose=0)

	ATSolver2D ()=delete

	~ATSolver2D ()=default

	ATSolver2D (const ATSolver2D &other)=default

	ATSolver2D (ATSolver2D &&other)=default

ATSolver2D &	operator= (const ATSolver2D &other)=default

ATSolver2D &	operator= (ATSolver2D &&other)=default

Index	size (const int order) const

Initialization services
template<typename VectorFieldInput , typename SurfelRangeConstIterator >
void	initInputVectorFieldU2 (const VectorFieldInput &input, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE, bool normalize=false)

template<typename ScalarFieldInput , typename SurfelRangeConstIterator >
void	initInputScalarFieldU2 (const ScalarFieldInput &input, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)

template<typename ScalarVector >
Index	initInputVectorFieldU2 (const std::map< Surfel, ScalarVector > &input, bool normalize=false)

template<typename Scalar >
Index	initInputScalarFieldU2 (const std::map< Surfel, Scalar > &input)

void	setUp (double a, double l)

void	setUp (double a, double l, const std::map< Surfel, Scalar > &weights)

template<typename AlphaWeights , typename SurfelRangeConstIterator >
void	setUp (double a, double l, const AlphaWeights &weights, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)

void	setEpsilon (double e)

Optimization services
bool	solveOneAlternateStep ()

bool	solveForEpsilon (double eps, double n_oo_max=1e-4, unsigned int iter_max=10)

bool	solveGammaConvergence (double eps1=2.0, double eps2=0.25, double epsr=2.0, bool compute_smallest_epsilon_map=false, double n_oo_max=1e-4, unsigned int iter_max=10)

void	normalizeU2 ()

std::tuple< double, double, double >	diffV0 () const

Access services
std::tuple< double, double, double >	checkV0 () const

PrimalForm0	getV0 () const

PrimalForm1	getV1 () const

PrimalForm2	getV2 () const

PrimalForm2	getU2 (Dimension k) const

template<typename VectorFieldOutput , typename SurfelRangeConstIterator >
void	getOutputVectorFieldU2 (VectorFieldOutput &output, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)

template<typename ScalarFieldOutput , typename SurfelRangeConstIterator >
void	getOutputScalarFieldU2 (ScalarFieldOutput &output, SurfelRangeConstIterator itB, SurfelRangeConstIterator itE)

template<typename ScalarFieldOutput , typename CellRangeConstIterator >
void	getOutputScalarFieldV0 (ScalarFieldOutput &output, CellRangeConstIterator itB, CellRangeConstIterator itE, CellOutputPolicy policy=CellOutputPolicy::Average)

void	updateSmallestEpsilonMap (const double threshold=.5)

Interface services
void	selfDisplay (std::ostream &out) const

bool	isValid () const

Data Fields
Surfel2IndexMap	surfel2idx

SmallestEpsilonMap	smallest_epsilon_map

double	alpha

double	lambda

double	epsilon

bool	normalize_u2
	Indicates whether to normalize U (unit norm) at each iteration or not.

int	verbose
	Tells the verbose level.

Static Public Attributes
static const Dimension	dimension = KSpace::dimension

Protected Member Functions
Hidden services
void	initOperators ()
	Initializes the operators.

Protected Attributes
CountedConstPtrOrConstPtr< Calculus >	ptrCalculus
	A smart (or not) pointer to a calculus object.

PrimalDerivative0	primal_D0
	the derivative operator for primal 0-forms

PrimalDerivative1	primal_D1
	the derivative operator for primal 1-forms

PrimalDerivative0	M01
	The primal vertex to edge average operator.

PrimalDerivative1	M12
	The primal edge to face average operator.

PrimalAntiderivative2	primal_AD2
	The antiderivative of primal 2-forms.

PrimalIdentity2	alpha_Id2
	The alpha-weighted identity operator for primal 2-forms (stored for performance)

PrimalIdentity0	l_1_over_4e_Id0
	The 1/(4epsilon)-weighted identity operator for primal 0-forms (stored for performance)

std::vector< PrimalForm2 >	g2
	The N-array of input primal 2-forms g.

std::vector< PrimalForm2 >	alpha_g2
	The alpha-weighted N-array of input primal 2-forms g.

std::vector< PrimalForm2 >	u2
	The N-array of regularized primal 2-forms u.

PrimalForm0	v0

PrimalForm0	former_v0
	The primal 0-form v at the previous iteration.

PrimalForm0	l_1_over_4e
	The primal 0-form lambda/(4epsilon) (stored for performance)

Detailed Description

template<typename TKSpace, typename TLinearAlgebra = EigenLinearAlgebraBackend>
class DGtal::ATSolver2D< TKSpace, TLinearAlgebra >

Aim: This class solves Ambrosio-Tortorelli functional on a two-dimensional digital space (a 2D grid or 2D digital surface) for a piecewise smooth scalar/vector function u represented as one/several 2-form(s) and a discontinuity function v represented as a 0-form. The 2-form(s) u is a regularized approximation of an input vector data g, while v represents the set of discontinuities of u. The norm chosen for u is the \( l_2 \)-norm.

Description of template class 'ATSolver2D'

Template Parameters

TKSpace	any model of CCellularGridSpaceND, e.g KhalimskySpaceND
TLinearAlgebra	any back-end for performing linear algebra, default is EigenLinearAlgebraBackend.

// Typical use (with appropriate definitions for types and variables).
typedef DiscreteExteriorCalculusFactory<EigenLinearAlgebraBackend> CalculusFactory;
const auto calculus = CalculusFactory::createFromNSCells<2>( surfels.begin(), surfels.end() );
ATSolver2D< KSpace > at_solver(calculus, 1);
at_solver.initInputVectorFieldU2( normals, surfels.cbegin(), surfels.cend() );
at_solver.setUp( alpha_at, lambda_at );
at_solver.solveGammaConvergence( 2.0, 0.5, 2.0 );
at_solver.getOutputVectorFieldU2( normals, surfels.cbegin(), surfels.cend() );

See also: exampleSurfaceATNormals.cpp

Definition at line 90 of file ATSolver2D.h.

Member Typedef Documentation

◆ Calculus

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef DiscreteExteriorCalculus<2,dimension, LinearAlgebra> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Calculus

Definition at line 114 of file ATSolver2D.h.

◆ Cell

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef KSpace::Cell DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Cell

Definition at line 111 of file ATSolver2D.h.

◆ Domain

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef HyperRectDomain<Space> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Domain

Definition at line 113 of file ATSolver2D.h.

◆ Index

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::Index DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Index

Definition at line 116 of file ATSolver2D.h.

◆ KSpace

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef TKSpace DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::KSpace

Definition at line 95 of file ATSolver2D.h.

◆ LinearAlgebra

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef TLinearAlgebra DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::LinearAlgebra

Definition at line 96 of file ATSolver2D.h.

◆ LinearAlgebraSolver

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef EigenLinearAlgebraBackend::SolverSimplicialLDLT DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::LinearAlgebraSolver

Definition at line 138 of file ATSolver2D.h.

◆ PrimalAntiderivative1

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalAntiderivative1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalAntiderivative1

Definition at line 125 of file ATSolver2D.h.

◆ PrimalAntiderivative2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalAntiderivative2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalAntiderivative2

Definition at line 126 of file ATSolver2D.h.

◆ PrimalDerivative0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalDerivative0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalDerivative0

Definition at line 123 of file ATSolver2D.h.

◆ PrimalDerivative1

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalDerivative1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalDerivative1

Definition at line 124 of file ATSolver2D.h.

◆ PrimalForm0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalForm0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalForm0

Definition at line 117 of file ATSolver2D.h.

◆ PrimalForm1

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalForm1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalForm1

Definition at line 118 of file ATSolver2D.h.

◆ PrimalForm2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalForm2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalForm2

Definition at line 119 of file ATSolver2D.h.

◆ PrimalHodge0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalHodge0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalHodge0

Definition at line 127 of file ATSolver2D.h.

◆ PrimalHodge1

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalHodge1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalHodge1

Definition at line 128 of file ATSolver2D.h.

◆ PrimalHodge2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalHodge2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalHodge2

Definition at line 129 of file ATSolver2D.h.

◆ PrimalIdentity0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalIdentity0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalIdentity0

Definition at line 120 of file ATSolver2D.h.

◆ PrimalIdentity1

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalIdentity1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalIdentity1

Definition at line 121 of file ATSolver2D.h.

◆ PrimalIdentity2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Calculus::PrimalIdentity2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::PrimalIdentity2

Definition at line 122 of file ATSolver2D.h.

◆ RealVector

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef Space::RealVector DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::RealVector

Definition at line 108 of file ATSolver2D.h.

◆ Scalar

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef RealVector::Component DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Scalar

Definition at line 109 of file ATSolver2D.h.

◆ SCell

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef KSpace::SCell DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::SCell

Definition at line 110 of file ATSolver2D.h.

◆ Self

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef ATSolver2D< KSpace, LinearAlgebra > DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Self

Definition at line 97 of file ATSolver2D.h.

◆ SmallestEpsilonMap

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef KSpace::template SurfelMap<double>::Type DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::SmallestEpsilonMap

Definition at line 115 of file ATSolver2D.h.

◆ SolverU2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef DiscreteExteriorCalculusSolver<Calculus, LinearAlgebraSolver, 2, PRIMAL, 2, PRIMAL> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::SolverU2

Definition at line 139 of file ATSolver2D.h.

◆ SolverV0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef DiscreteExteriorCalculusSolver<Calculus, LinearAlgebraSolver, 0, PRIMAL, 0, PRIMAL> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::SolverV0

Definition at line 140 of file ATSolver2D.h.

◆ Space

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef KSpace::Space DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Space

Definition at line 107 of file ATSolver2D.h.

◆ Surfel

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef KSpace::Surfel DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Surfel

Definition at line 112 of file ATSolver2D.h.

◆ Surfel2IndexMap

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

typedef KSpace::template SurfelMap<Index>::Type DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Surfel2IndexMap

Definition at line 130 of file ATSolver2D.h.

Member Enumeration Documentation

◆ CellOutputPolicy

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

enum DGtal::ATSolver2D::CellOutputPolicy

Specifies how to merge the different values of 0-form v at cell vertices when outputing the 0-form v for a range of cells (either pointels, linels, surfels).

Enumerator
Average	compute average values at cell vertices
Minimum	compute minimum value at cell vertices,
Maximum	compute maximum value at cell vertices

Definition at line 103 of file ATSolver2D.h.

                          { Average, 
                            Minimum, 
                            Maximum, 
    };

Constructor & Destructor Documentation

◆ ATSolver2D() [1/4]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ATSolver2D	(	ConstAlias< Calculus >	aCalculus,
		int	aVerbose = 0 )

inline

Prepare an AT-solver from a valid calculus.

Parameters

aCalculus	any valid calculus
aVerbose	tells how the solver displays computing information: 0 none, 1 more, 2 even more...

See also: DiscreteExteriorCalculusFactory for creating calculus objects.

Definition at line 202 of file ATSolver2D.h.

      : ptrCalculus( aCalculus ),
        primal_D0( *ptrCalculus ), primal_D1( *ptrCalculus ),
        M01( *ptrCalculus ), M12( *ptrCalculus ), primal_AD2( *ptrCalculus ),
        alpha_Id2( *ptrCalculus ), l_1_over_4e_Id0( *ptrCalculus ),
        g2(), alpha_g2(), u2(), v0( *ptrCalculus ), former_v0( *ptrCalculus ),
        l_1_over_4e( *ptrCalculus ), verbose( aVerbose )
    {
      if ( verbose >= 2 )
        trace.info() << "[ATSolver::ATSolver] " << *ptrCalculus << std::endl;
      initOperators();
      const auto size2 = ptrCalculus->kFormLength( 2, PRIMAL );
      for ( Index index = 0; index < size2; ++index) {
        const auto& calculus_cell = ptrCalculus->getSCell( 2, PRIMAL, index );
        surfel2idx[ calculus_cell ] = index;
      }
    }

References DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators(), DGtal::PRIMAL, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

◆ ATSolver2D() [2/4]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ATSolver2D ( )

delete

Default constructor.

◆ ~ATSolver2D()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::~ATSolver2D ( )

default

Destructor.

◆ ATSolver2D() [3/4]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ATSolver2D ( const ATSolver2D< TKSpace, TLinearAlgebra > & other )

default

Copy constructor.

Parameters

other the object to clone.

◆ ATSolver2D() [4/4]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ATSolver2D ( ATSolver2D< TKSpace, TLinearAlgebra > && other )

default

Move constructor.

Parameters

other the object to move.

Member Function Documentation

◆ checkV0()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

std::tuple< double, double, double > DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::checkV0 ( ) const

inline

Debug method for checking if v is a scalar field between 0 and 1.

Returns: the tuple (min(v), average(v), max(v))

Definition at line 723 of file ATSolver2D.h.

    {
      const double m1 = v0.myContainer.minCoeff();
      const double m2 = v0.myContainer.maxCoeff();
      const double ma = v0.myContainer.mean();
      if ( verbose >= 1 )
        trace.info() << "0-form v (should be in [0,1]): min=" << m1 << " avg=" << ma << " max=" << m2 << std::endl;
      return std::make_tuple( m1, m2, ma );
    }

References DGtal::Trace::info(), DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::selfDisplay().

◆ diffV0()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

std::tuple< double, double, double > DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::diffV0 ( ) const

inline

Computes the norms loo, l2, l1 of (v - former_v), i.e. the evolution of discontinuity function v.

Returns: a tuple (n_infty,n_2,n_1) giving the loo/l2/l1-norm of (v - former_v)

Definition at line 702 of file ATSolver2D.h.

    {
      PrimalForm0 delta = v0 - former_v0;
      delta.myContainer = delta.myContainer.cwiseAbs();
      const double n_oo = delta.myContainer.maxCoeff();
      const double n_2  = std::sqrt(delta.myContainer.squaredNorm()/delta.myContainer.size());
      const double n_1  = delta.myContainer.mean();
      return std::make_tuple( n_oo, n_2, n_1 );
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::former_v0, and DGtal::KForm< TCalculus, order, duality >::myContainer.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveForEpsilon().

◆ getOutputScalarFieldU2()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename ScalarFieldOutput , typename SurfelRangeConstIterator >

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldU2	(	ScalarFieldOutput &	output,
		SurfelRangeConstIterator	itB,
		SurfelRangeConstIterator	itE )

inline

Given a range of surfels [itB,itE), returns in output the regularized scalar field u.

Template Parameters

ScalarFieldOutput	the type of scalar field for output values (RandomAccess container)
SurfelRangeConstIterator	the type of iterator for traversing a range of surfels

Parameters

[out]	output	the vector of output values (a scalar field), which should be of size `length(itB,itE)`
	itB	the start of the range of surfels.
	itE	past the end of the range of surfels.

Definition at line 798 of file ATSolver2D.h.

    {
      ASSERT( u2.size() == 1 && "[ATSolver2D::getOutputScalarFieldU2] "
              "You try to output a scalar field from a vector field." );
      Index i = 0;
      for ( auto it = itB; it != itE; ++it, ++i )
        {
          Index idx = surfel2idx[ *it ];
          output[ i ] = u2[ 0 ].myContainer( idx );
        }
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), and DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation().

◆ getOutputScalarFieldV0()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename ScalarFieldOutput , typename CellRangeConstIterator >

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldV0	(	ScalarFieldOutput &	output,
		CellRangeConstIterator	itB,
		CellRangeConstIterator	itE,
		CellOutputPolicy	policy = CellOutputPolicy::Average )

inline

Given a range of pointels, linels or 2-cells [itB,itE), returns in output the feature vector v (the average of v for linels/surfels).

Template Parameters

ScalarFieldOutput	the type of scalar field for output values (RandomAccess container)
CellRangeConstIterator	the type of iterator for traversing a range of cells

Parameters

[out]	output	the vector of output scalar values (a scalar field), which should be of size `length(itB,itE)`
[in]	itB	the start of the range of cells.
[in]	itE	past the end of the range of cells.
[in]	policy	the chosen policy for outputing v values for a given cell.

Definition at line 824 of file ATSolver2D.h.

    {
      const KSpace& K = ptrCalculus->myKSpace;
      const Dimension k = K.uDim( *itB );
      ASSERT( k <= 2 );
      Index i = 0;
      if ( k == 0 )
        {
          for ( auto it = itB; it != itE; ++it, ++i )
            {
              const Cell pointel = *it;
              const Index    idx = ptrCalculus->getCellIndex( pointel );
              output[ i ] = v0.myContainer( idx );
            }
        }
      else if ( k == 1 )
        {
          for ( auto it = itB; it != itE; ++it, ++i )
            {
              const Cell  linel = *it;
              const Dimension d = * K.uDirs( linel );
              const Cell     p0 = K.uIncident( linel, d, false );
              const Cell     p1 = K.uIncident( linel, d, true  );
              const Index  idx0 = ptrCalculus->getCellIndex( p0 );
              const Index  idx1 = ptrCalculus->getCellIndex( p1 );
              switch (policy) {
              case CellOutputPolicy::Average: output[ i ] = 0.5 * ( v0.myContainer( idx0 ) + v0.myContainer( idx1 ) );
                break;
              case CellOutputPolicy::Minimum: output[ i ] = std::min( v0.myContainer( idx0 ), v0.myContainer( idx1 ) );
                break;
              case CellOutputPolicy::Maximum: output[ i ] = std::max( v0.myContainer( idx0 ), v0.myContainer( idx1 ) );
                break;
              }
            }
        }
      else if ( k == 2 )
        {
          for ( auto it = itB; it != itE; ++it, ++i )
            {
              const Cell   face = *it;
              const Dimension d = * K.uDirs( face );
              const Cell     l0 = K.uIncident( face, d, false );
              const Cell     l1 = K.uIncident( face, d, true  );
              const Dimension j = * K.uDirs( l0 );
              const Cell    p00 = K.uIncident( l0, j, false );
              const Cell    p01 = K.uIncident( l0, j, true  );
              const Cell    p10 = K.uIncident( l1, j, false );
              const Cell    p11 = K.uIncident( l1, j, true  );
              const Index idx00 = ptrCalculus->getCellIndex( p00 );
              const Index idx01 = ptrCalculus->getCellIndex( p01 );
              const Index idx10 = ptrCalculus->getCellIndex( p10 );
              const Index idx11 = ptrCalculus->getCellIndex( p11 );
              switch (policy) {
              case CellOutputPolicy::Average:
                output[ i ] = 0.25 * ( v0.myContainer( idx00 ) + v0.myContainer( idx01 )
                                       + v0.myContainer( idx10 ) + v0.myContainer( idx11 ) );
                break;
              case CellOutputPolicy::Minimum:
                output[ i ] = std::min( std::min( v0.myContainer( idx00 ), v0.myContainer( idx01 ) ),
                                        std::min( v0.myContainer( idx10 ), v0.myContainer( idx11 ) ) );
                break;
              case CellOutputPolicy::Maximum:
                output[ i ] = std::max( std::max( v0.myContainer( idx00 ), v0.myContainer( idx01 ) ),
                                        std::max( v0.myContainer( idx10 ), v0.myContainer( idx11 ) ) );
                break;
              }
            }
        }
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Average, K, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Maximum, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::Minimum, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), and main().

◆ getOutputVectorFieldU2()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename VectorFieldOutput , typename SurfelRangeConstIterator >

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputVectorFieldU2	(	VectorFieldOutput &	output,
		SurfelRangeConstIterator	itB,
		SurfelRangeConstIterator	itE )

inline

Given a range of surfels [itB,itE), returns in output the regularized vector field u.

Template Parameters

VectorFieldOutput	the type of vector field for output values (RandomAccess container)
SurfelRangeConstIterator	the type of iterator for traversing a range of surfels

Parameters

[out]	output	the vector of output values (a scalar or vector field depending on input).
	itB	the start of the range of surfels.
	itE	past the end of the range of surfels.

Definition at line 772 of file ATSolver2D.h.

    {
      const Dimension N = u2.size();
      Index i = 0;
      for ( auto it = itB; it != itE; ++it, ++i )
        {
          Index idx = surfel2idx[ *it ];
          ASSERT( output[ i ].size() >= N );
          for ( Dimension k = 0; k < N; ++k )
            output[ i ][ k ] = u2[ k ].myContainer( idx );
        }
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), and main().

◆ getU2()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getU2 ( Dimension k ) const

inline

Parameters

k	an integer such that `0 <= k < u2.size()`

Returns: the k-th piecewise smooth function u as a primal 2-form.

Definition at line 754 of file ATSolver2D.h.

    {
      return u2[ k ];
    }

◆ getV0()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV0 ( ) const

inline

Returns: the discontinuity function v as a primal 0-form.

Definition at line 735 of file ATSolver2D.h.

    {
      return v0;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::v0.

◆ getV1()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV1 ( ) const

inline

Returns: the discontinuity function v as a primal 1-form.

Definition at line 741 of file ATSolver2D.h.

    {
      return M01*v0;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M01, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::v0.

◆ getV2()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV2 ( ) const

inline

Returns: the discontinuity function u as a primal 2-form.

Definition at line 747 of file ATSolver2D.h.

    {
      return M12*M01*v0;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M01, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M12, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::v0.

◆ initInputScalarFieldU2() [1/2]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename ScalarFieldInput , typename SurfelRangeConstIterator >

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2	(	const ScalarFieldInput &	input,
		SurfelRangeConstIterator	itB,
		SurfelRangeConstIterator	itE )

inline

Given a range of surfels [itB,itE) and an input scalar field, initializes the AT 2-forms u and g. The 0-form v is itself initialized to 1 everywhere.

Template Parameters

ScalarFieldInput	the type of scalar field for input values (RandomAccess container)
SurfelRangeConstIterator	the type of iterator for traversing a range of surfels

Parameters

[in]	input	the input scalar field (a vector of scalar values)
	itB	the start of the range of surfels.
	itE	past the end of the range of surfels.

Definition at line 330 of file ATSolver2D.h.

    {
      if ( verbose >= 1 )
        trace.beginBlock( "[ATSolver2D::initInputVectorFieldU2] Initializing input data" );
      ASSERT( ! input.empty() );
      if ( verbose >= 2 ) trace.info() << "input g as one 2-form." << std::endl;
      g2       = std::vector<PrimalForm2>( 1, PrimalForm2( *ptrCalculus ) );
      alpha_g2 = std::vector<PrimalForm2>( 1, PrimalForm2( *ptrCalculus ) );
      Index i = 0;
      for ( auto it = itB; it != itE; ++it, ++i )
        {
          Index idx = surfel2idx[ *it ];
          g2[ 0 ].myContainer( idx ) = input[ i ]; 
        }
      // u = g at the beginning
      if ( verbose >= 2 )
        trace.info() << "Unknown u[:] = g[:] at beginning." << std::endl;
       u2 = g2;
      // v = 1 at the beginning
      if ( verbose >= 2 ) trace.info() << "Unknown v = 1" << std::endl;
      v0 = PrimalForm0::ones(*ptrCalculus);
      if ( verbose >= 1 ) trace.endBlock();
      normalize_u2 = false;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::normalize_u2, DGtal::KForm< TCalculus, order, duality >::ones(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), and DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation().

◆ initInputScalarFieldU2() [2/2]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename Scalar >

Index DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2 ( const std::map< Surfel, Scalar > & input )

inline

Given a map Surfel -> Scalar, initializes forms g, u and v of the AT solver. Note that there is only one 2-form u/g.

Parameters

input any map Surfel -> Scalar

Returns: the number of cells that were initialized.

Template Parameters

Scalar any type representing a scalar (float, double)

Definition at line 411 of file ATSolver2D.h.

    {
      if ( verbose >= 1 ) trace.beginBlock( "[ATSolver2D::initScalarInput] Initializing input data" );
      if ( verbose >= 2 ) trace.info() << "discontinuity 0-form v = 1." << std::endl;
      v0 = PrimalForm0::ones(*ptrCalculus);
      if ( verbose >= 2 ) trace.info() << "input g as one 2-form." << std::endl;
      g2       = std::vector<PrimalForm2>( 1, PrimalForm2( *ptrCalculus ) );
      alpha_g2 = std::vector<PrimalForm2>( 1, PrimalForm2( *ptrCalculus ) );
      const Scalar zero;
      Index nbok = 0;
      for ( Index index = 0; index < size(2); index++)
        {
          const SCell& cell = g2[ 0 ].getSCell( index );
          const auto   it   = input.find( cell );  
          const auto   n    = ( it != input.end() ) ? *it : zero;
          nbok             += ( it != input.end() ) ? 1 : 0;
          g2[ 0 ].myContainer( index ) = n;
        }
      // u = g at the beginning
      if ( verbose >= 2 ) trace.info() << "Unknown u[:] = g[:] at beginning." << std::endl;
      u2 = g2;
      // v = 1 at the beginning
      if ( verbose >= 2 ) trace.info() << "Unknown v = 1" << std::endl;
      v0 = PrimalForm0::ones(*ptrCalculus);
      if ( verbose >= 1 ) trace.endBlock();
      normalize_u2 = false;
      return nbok;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::normalize_u2, DGtal::KForm< TCalculus, order, duality >::ones(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

◆ initInputVectorFieldU2() [1/2]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename ScalarVector >

Index DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2	(	const std::map< Surfel, ScalarVector > &	input,
		bool	normalize = false )

inline

Given a map Surfel -> ScalarVector, initializes forms g, u and v of the AT solver. Note that there are as many 2-forms u/g as the number of dimensions of ScalarVector.

Parameters

input	any map Surfel -> ScalarVector
normalize	when 'true', the input is supposed to be a unit vector field and the solver will output a unit regularized vector field at the end of each minimization step.

Returns: the number of cells that were initialized.

Template Parameters

ScalarVector any type representing a vector/array of scalars (float, double)

Definition at line 371 of file ATSolver2D.h.

    {
      if ( verbose >= 1 ) trace.beginBlock( "[ATSolver2D::initVectorInput] Initializing input data" );
      if ( verbose >= 2 ) trace.info() << "discontinuity 0-form v = 1." << std::endl;
      const Dimension N = ScalarVector().size();
      if ( verbose >= 2 ) trace.info() << "input g as " << N << " 2-forms." << std::endl;
      g2       = std::vector<PrimalForm2>( N, PrimalForm2( *ptrCalculus ) );
      alpha_g2 = std::vector<PrimalForm2>( N, PrimalForm2( *ptrCalculus ) );
      const ScalarVector zero;
      Index              nbok = 0;
      for ( Index index = 0; index < size(2); index++)
        {
          const SCell& cell = g2[ 0 ].getSCell( index );
          const auto   it   = input.find( cell );  
          const auto   n    = ( it != input.end() ) ? it->second : zero;
          nbok             += ( it != input.end() ) ? 1 : 0;
          for ( Dimension k = 0; k < N; ++k )
            g2[ k ].myContainer( index ) = n[ k ];
        }
      // u = g at the beginning
      if ( verbose >= 2 )
        trace.info() << "Unknown u[:] = g[:] at beginning." << std::endl;
      u2 = g2;
      // v = 1 at the beginning
      if ( verbose >= 2 ) trace.info() << "Unknown v = 1" << std::endl;
      v0 = PrimalForm0::ones(*ptrCalculus);
      if ( verbose >= 1 ) trace.endBlock();
      normalize_u2 = normalize;
      return nbok;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::normalize_u2, DGtal::KForm< TCalculus, order, duality >::ones(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

◆ initInputVectorFieldU2() [2/2]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename VectorFieldInput , typename SurfelRangeConstIterator >

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2	(	const VectorFieldInput &	input,
		SurfelRangeConstIterator	itB,
		SurfelRangeConstIterator	itE,
		bool	normalize = false )

inline

Given a range of surfels [itB,itE) and an input vector field, initializes the AT 2-forms u and g. The 0-form v is itself initialized to 1 everywhere.

Template Parameters

VectorFieldInput	the type of vector field for input values (RandomAccess container)
SurfelRangeConstIterator	the type of iterator for traversing a range of surfels

Parameters

[in]	input	the input vector field (a vector of vector values)
[in]	itB	the start of the range of surfels.
[in]	itE	past the end of the range of surfels.
[in]	normalize	when 'true', the input is supposed to be a unit vector field and the solver will output a unit regularized vector field at the end of each minimization step.

Definition at line 288 of file ATSolver2D.h.

    {
      if ( verbose >= 1 )
        trace.beginBlock( "[ATSolver2D::initInputVectorFieldU2] Initializing input data" );
      ASSERT( ! input.empty() );
      const Dimension N = input[ 0 ].size();
      if ( verbose >= 2 ) trace.info() << "input g as " << N << " 2-forms." << std::endl;
      g2       = std::vector<PrimalForm2>( N, PrimalForm2( *ptrCalculus ) );
      alpha_g2 = std::vector<PrimalForm2>( N, PrimalForm2( *ptrCalculus ) );
      Index i = 0;
      for ( auto it = itB; it != itE; ++it, ++i )
        {
          Index idx = surfel2idx[ *it ];
          for ( Dimension k = 0; k < N; ++k )
            g2[ k ].myContainer( idx ) = input[ i ][ k ]; 
        }
      // u = g at the beginning
      if ( verbose >= 2 )
        trace.info() << "Unknown u[:] = g[:] at beginning." << std::endl;
       u2 = g2;
      // v = 1 at the beginning
      if ( verbose >= 2 ) trace.info() << "Unknown v = 1" << std::endl;
      v0 = PrimalForm0::ones(*ptrCalculus);
      if ( verbose >= 1 ) trace.endBlock();
      normalize_u2 = normalize;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::normalize_u2, DGtal::KForm< TCalculus, order, duality >::ones(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), and main().

◆ initOperators()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators ( )

inlineprotected

Initializes the operators.

Definition at line 976 of file ATSolver2D.h.

    {
      if ( verbose >= 1 ) trace.beginBlock( "[ATSolver2D::initOperators] Solver initialization" );
      if ( verbose >= 2 ) trace.info() << "derivative of primal 0-forms: primal_D0" << std::endl;
      primal_D0 = ptrCalculus->template derivative<0,PRIMAL>();
      if ( verbose >= 2 ) trace.info() << "derivative of primal 1-forms: primal_D1" << std::endl;
      primal_D1 = ptrCalculus->template derivative<1,PRIMAL>();
      if ( verbose >= 2 ) trace.info() << "antiderivative of primal 2-forms: primal_AD2" << std::endl;
      primal_AD2 = ptrCalculus->template antiderivative<2,PRIMAL>();
      if ( verbose >= 2 ) trace.info() << "vertex to edge average operator: M01" << std::endl;
      M01       = primal_D0;
      M01.myContainer = .5 * M01.myContainer.cwiseAbs();
      if ( verbose >= 2 ) trace.info() << "edge to face average operator: M12" << std::endl;
      M12       = primal_D1;
      M12.myContainer = .25 * M12.myContainer.cwiseAbs();
      if ( verbose >= 1 ) trace.endBlock();
    }

References DGtal::Trace::beginBlock(), DGtal::derivative(), DGtal::Trace::endBlock(), DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M01, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M12, DGtal::LinearOperator< TCalculus, order_in, duality_in, order_out, duality_out >::myContainer, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::primal_AD2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::primal_D0, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::primal_D1, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ATSolver2D().

◆ isValid()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

bool DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::isValid ( ) const

inline

Checks the validity/consistency of the object.

Returns: 'true' if the object is valid, 'false' otherwise.

Definition at line 962 of file ATSolver2D.h.

    {
      return true;
    }

◆ normalizeU2()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::normalizeU2 ( )

inline

Forces the normalization of the vector u, meaning for all index i, \( \sum_{k=0}^{K-1} u[k][i]^2 = 1 \). Can be useful in some applications where you are looking for unitary vector field.

Definition at line 684 of file ATSolver2D.h.

    {
      for ( Index index = 0; index < size( 2 ); index++)
        {
          double n2 = 0.0;
          for ( unsigned int d = 0; d < u2.size(); ++d )
            n2 += u2[ d ].myContainer( index ) * u2[ d ].myContainer( index );
          double norm = sqrt( n2 );
          if (norm == 0.0) continue;
          for ( unsigned int d = 0; d < u2.size(); ++d )
            u2[ d ].myContainer( index ) /= norm;
        }
    }

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ operator=() [1/2]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

ATSolver2D & DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::operator= ( ATSolver2D< TKSpace, TLinearAlgebra > && other )

default

Move assignment operator.

Parameters

other the object to move.

Returns: a reference on 'this'.

◆ operator=() [2/2]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

ATSolver2D & DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::operator= ( const ATSolver2D< TKSpace, TLinearAlgebra > & other )

default

Copy assignment operator.

Parameters

other the object to copy.

Returns: a reference on 'this'.

◆ selfDisplay()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::selfDisplay ( std::ostream & out ) const

inline

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

Definition at line 949 of file ATSolver2D.h.

    {
      auto cv = checkV0();
      out << "[ATSolver2D] v is between min/avg/max:"
          << std::get<0>(cv) << "/"
          << std::get<1>(cv) << "/"
          << std::get<2>(cv) << std::endl;
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::checkV0().

◆ setEpsilon()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setEpsilon ( double e )

inline

Initializes the epsilon parameter of AT and precomputes the assaociated forms and operators.

Parameters

e	the epsilon parameter in AT

Definition at line 525 of file ATSolver2D.h.

    {
      epsilon         = e;
      l_1_over_4e     = (lambda/4./epsilon)*PrimalForm0::ones(*ptrCalculus);
      l_1_over_4e_Id0 = (lambda/4./epsilon)*ptrCalculus->template identity<0, PRIMAL>();
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::epsilon, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::l_1_over_4e, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::l_1_over_4e_Id0, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::lambda, DGtal::KForm< TCalculus, order, duality >::ones(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveForEpsilon().

◆ setUp() [1/3]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp	(	double	a,
		double	l )

inline

Initializes the alpha and lambda parameters of AT.

Parameters

a	the global alpha parameter
l	the global lambda parameter

Note: all 2-cells have the same weight for the data term.

Definition at line 444 of file ATSolver2D.h.

    {
      const Dimension N = (Dimension)g2.size();
      alpha     = a;
      lambda    = l;
      alpha_Id2 = alpha * ptrCalculus->template identity<2, PRIMAL>();
      for ( Dimension k = 0; k < N; ++k )
        alpha_g2[ k ] = alpha * g2[ k ];
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_Id2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::lambda, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), and main().

◆ setUp() [2/3]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

template<typename AlphaWeights , typename SurfelRangeConstIterator >

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp	(	double	a,
		double	l,
		const AlphaWeights &	weights,
		SurfelRangeConstIterator	itB,
		SurfelRangeConstIterator	itE )

inline

Initializes the alpha and lambda parameters of AT, with weights on the 2-cells for the data terms.

Template Parameters

AlphaWeights	the type of RandomAccess container for alpha weight values
SurfelRangeConstIterator	the type of iterator for traversing a range of surfels

Parameters

[in]	a	the global alpha parameter
[in]	l	the global lambda parameter
[in]	weights	the vector of alpha weights for each surfel of the range [itB,itE)
[in]	itB	the start of the range of surfels.
[in]	itE	past the end of the range of surfels.

Note: Useful for inpainting applications or for adaptive piecewise smooth reconstruction.

Definition at line 499 of file ATSolver2D.h.

    {
      const Dimension N = g2.size();
      alpha  = a;
      lambda = l;
      PrimalForm2 w_form( *ptrCalculus );
      if ( verbose >= 2 )
        trace.info() << "Using variable weights for fitting (alpha term)" << std::endl;
      for ( Dimension k = 0; k < N; ++k )
        alpha_g2[ k ] = alpha * g2[ k ];
      Index i = 0;
      for ( auto it = itB; it != itE; ++it, ++i )
        {
          const Index idx = surfel2idx[ *it ];
          const Scalar  w = weights[ i ];
          w_form.myContainer( idx ) = w;
          for ( Dimension k = 0; k < N; ++k )
            alpha_g2[ k ].myContainer( idx ) *= w;
        }
      alpha_Id2 = alpha * diagonal( w_form );
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_Id2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::lambda, DGtal::KForm< TCalculus, order, duality >::myContainer, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

◆ setUp() [3/3]

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp	(	double	a,
		double	l,
		const std::map< Surfel, Scalar > &	weights )

inline

Initializes the alpha and lambda parameters of AT, with weights on the 2-cells for the data terms.

Parameters

a	the global alpha parameter
l	the global lambda parameter
weights	the map Surfel -> Scalar that gives the weight of each 2-cell in the data terms.

Note: Useful for inpainting applications or for adaptive piecewise smooth reconstruction.

Definition at line 463 of file ATSolver2D.h.

    {
      const Dimension N = g2.size();
      alpha  = a;
      lambda = l;
      PrimalForm2 w_form( *ptrCalculus );
      if ( verbose >= 2 )
        trace.info() << "Using variable weights for fitting (alpha term)" << std::endl;
      for ( Dimension k = 0; k < N; ++k )
        alpha_g2[ k ] = alpha * g2[ k ];
      for ( Index index = 0; index < size( 2 ); index++)
        {
          const SCell&           cell = g2[ 0 ].getSCell( index );
          const Scalar&             w = weights[ cell ];
          w_form.myContainer( index ) = w;
          for ( Dimension k = 0; k < N; ++k )
            alpha_g2[ k ].myContainer( index ) *= w;
        }
      alpha_Id2 = alpha * diagonal( w_form );
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_Id2, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2, DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::lambda, DGtal::KForm< TCalculus, order, duality >::myContainer, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

◆ size()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

Index DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::size ( const int order ) const

inline

Parameters

order the dimension of cells (0,1,2)

Returns: the number of cells with dimension order

Definition at line 258 of file ATSolver2D.h.

    {
      return ptrCalculus->kFormLength(order, PRIMAL);
    }

References DGtal::PRIMAL, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus.

◆ solveForEpsilon()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

bool DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveForEpsilon	(	double	eps,
		double	n_oo_max = 1e-4,
		unsigned int	iter_max = 10 )

inline

Solves the alternate minimization of AT for a given eps. Solves for u then for v till convergence.

Parameters

eps	the epsilon parameter at which AT is solved.
n_oo_max	the alternate minimization will stop when the loo-norm of \( v^{k+1} - v^k \) is below this bound.
iter_max	the alternate minimization will stop when the number of minimization steps exceeds iter_max.

Returns: true if everything went fine, false if there was a problem in the optimization.

Note: Use diffV0 to check if you are close to a critical point of AT.

Definition at line 605 of file ATSolver2D.h.

    {
      (void)n_oo_max;//paramerter not used
 
      bool ok = true;
      if ( verbose >= 1 ) {
        std::ostringstream sstr;
        sstr << "******* Solving AT for epsilon = " << eps << " **********";
        trace.beginBlock( sstr.str() ); 
      }
      setEpsilon( eps );
      for ( unsigned int i = 0; i < iter_max; ++i )
        {
          if ( verbose >= 1 )
            trace.info() << "---------- Iteration "
                         << i << "/" << iter_max << " ---------------" << std::endl;
          solveOneAlternateStep( );
          auto diffs_v = diffV0();
          if ( verbose >= 1 ) {
            trace.info() << "Variation |v^k+1 - v^k|_oo = " << std::get<0>( diffs_v )
                         << std::endl;
            if ( verbose >= 2 ) {
              trace.info() << "Variation |v^k+1 - v^k|_2  = " << std::get<1>( diffs_v )
                           << std::endl;
              trace.info() << "Variation |v^k+1 - v^k|_1  = " << std::get<2>( diffs_v )
                           << std::endl;
            }
          }
          if ( std::get<0>( diffs_v ) < 1e-4 ) break;
        }
      if ( verbose >= 1 ) trace.endBlock();
      return ok;
    }

References DGtal::Trace::beginBlock(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::diffV0(), DGtal::Trace::endBlock(), DGtal::Trace::info(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setEpsilon(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep(), DGtal::trace, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence().

◆ solveGammaConvergence()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

bool DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence	(	double	eps1 = 2.0,
		double	eps2 = 0.25,
		double	epsr = 2.0,
		bool	compute_smallest_epsilon_map = false,
		double	n_oo_max = 1e-4,
		unsigned int	iter_max = 10 )

inline

Solves AT by progressively decreasing epsilon from eps1 to eps2. AT is solved with solveForEpsilon at each epsilon.

Parameters

eps1	the first epsilon parameter at which AT is solved.
eps2	the last epsilon parameter at which AT is solved.
epsr	the ratio (>1) used to decrease progressively epsilon.
compute_smallest_epsilon_map	when 'true' determines for each surfel the smallest epsilon for which it is a discontinuity.
n_oo_max	the alternate minimization will stop when the loo-norm of \( v^{k+1} - v^k \) is below this bound.
iter_max	the alternate minimization will stop when the number of minimization steps exceeds iter_max.

Returns: true if everything went fine, false if there was a problem in the optimization.

Definition at line 657 of file ATSolver2D.h.

    {
      bool ok = true;
      if ( epsr <= 1.0 ) epsr = 2.0;
      if ( verbose >= 1 )
        trace.beginBlock( "#### Solve AT by Gamma-convergence ##########" );
      if ( compute_smallest_epsilon_map ) smallest_epsilon_map.clear();
      for ( double eps = eps1; eps >= eps2; eps /= epsr )
        {
          solveForEpsilon( eps, n_oo_max, iter_max );
          if ( compute_smallest_epsilon_map )
            updateSmallestEpsilonMap( 0.5 );
        }
      if ( verbose >= 1 )
        trace.endBlock();
      return ok;
    }

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::smallest_epsilon_map, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveForEpsilon(), DGtal::trace, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::updateSmallestEpsilonMap(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose.

Referenced by DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATScalarFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), DGtal::ShortcutsGeometry< TKSpace >::getATVectorFieldApproximation(), and main().

◆ solveOneAlternateStep()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

bool DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep ( )

inline

Solves one step of the alternate minimization of AT. Solves for u then for v.

Returns: true if everything went fine, false if there was a problem in the optimization.

Note: Use diffV0 to check if you are close to a critical point of AT.

Definition at line 546 of file ATSolver2D.h.

    {
      bool solve_ok = true;
      if ( verbose >= 1 ) trace.beginBlock("Solving for u as a 2-form");
      PrimalForm1 v1_squared = M01*v0;
      v1_squared.myContainer.array() = v1_squared.myContainer.array().square();
      const PrimalIdentity2 ope_u2 = alpha_Id2
        + primal_AD2.transpose() * dec_helper::diagonal( v1_squared ) * primal_AD2;
 
      if ( verbose >= 2 ) trace.info() << "Prefactoring matrix U associated to u" << std::endl;
      SolverU2 solver_u2;
      solver_u2.compute( ope_u2 );
      for ( Dimension d = 0; d < u2.size(); ++d )
        {
          if ( verbose >= 2 ) trace.info() << "Solving U u[" << d << "] = a g[" << d << "]" << std::endl;
          u2[ d ] = solver_u2.solve( alpha_g2[ d ] );
          if ( verbose >= 2 ) trace.info() << "  => " << ( solver_u2.isValid() ? "OK" : "ERROR" )
                                           << " " << solver_u2.myLinearAlgebraSolver.info() << std::endl;
          solve_ok = solve_ok && solver_u2.isValid();
        }
      if ( normalize_u2 ) normalizeU2();
      if ( verbose >= 1 ) trace.endBlock();
      if ( verbose >= 1 ) trace.beginBlock("Solving for v");
      former_v0 = v0;
      PrimalForm1 squared_norm_d_u2 = PrimalForm1::zeros(*ptrCalculus);
      for ( Dimension d = 0; d < u2.size(); ++d )
        squared_norm_d_u2.myContainer.array() += (primal_AD2 * u2[ d ] ).myContainer.array().square();
      trace.info() << "build metric u2" << std::endl;
      const PrimalIdentity0 ope_v0 = l_1_over_4e_Id0
        + (lambda * epsilon) * primal_D0.transpose() * primal_D0
        + M01.transpose() * dec_helper::diagonal( squared_norm_d_u2 ) * M01;
 
      if ( verbose >= 2 ) trace.info() << "Prefactoring matrix V associated to v" << std::endl;
      SolverV0 solver_v0;
      solver_v0.compute( ope_v0 );
      if ( verbose >= 2 ) trace.info() << "Solving V v = l/4e * 1" << std::endl;
      v0 = solver_v0.solve( l_1_over_4e );
      if ( verbose >= 2 ) trace.info() << "  => " << ( solver_v0.isValid() ? "OK" : "ERROR" )
                                       << " " << solver_v0.myLinearAlgebraSolver.info() << std::endl;
      solve_ok = solve_ok && solver_v0.isValid();
      if ( verbose >= 1 ) trace.endBlock();
      return solve_ok;
    }

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveForEpsilon().

◆ updateSmallestEpsilonMap()

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

void DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::updateSmallestEpsilonMap ( const double threshold = .5 )

inline

Computes the map that stores for each surfel the smallest epsilon for which the surfel was in the discontinuity zone (more precisely, the surfel has at least two vertices that belongs to the set of discontinuity).

Parameters

[in] threshold the threshold for discontinuity function v (below u is discontinuous, above u is continuous)

Definition at line 903 of file ATSolver2D.h.

    {
      const KSpace& K = ptrCalculus->myKSpace;
      for ( const SCell surfel : ptrCalculus->template getIndexedSCells<2, PRIMAL>() )
        {
          const Cell face            = K.unsigns( surfel );
          const Dimension    k1      = * K.uDirs( face );
          const Cell   l0      = K.uIncident( face, k1, false );
          const Cell   l1      = K.uIncident( face, k1, true );
          const Dimension    k2      = * K.uDirs( l0 );
          const Cell   ll0     = K.uIncident( face, k2, false );
          const Cell   ll1     = K.uIncident( face, k2, true );
          const Cell   p00     = K.uIncident( l0, k2, false );
          const Cell   p01     = K.uIncident( l0, k2, true );
          const Cell   p10     = K.uIncident( l1, k2, false );
          const Cell   p11     = K.uIncident( l1, k2, true );
 
          std::vector<double>  features( 4 );
          features[ 0 ] = v0.myContainer( ptrCalculus->getCellIndex( p00 ) );
          features[ 1 ] = v0.myContainer( ptrCalculus->getCellIndex( p01 ) );
          features[ 2 ] = v0.myContainer( ptrCalculus->getCellIndex( p10 ) );
          features[ 3 ] = v0.myContainer( ptrCalculus->getCellIndex( p11 ) );
          std::sort( features.begin(), features.end() );
 
          if ( features[ 1 ] <= threshold )
            {
              auto it = smallest_epsilon_map.find( surfel );
              if ( it != smallest_epsilon_map.end() )
                it->second = std::min( epsilon, it->second );
              else smallest_epsilon_map[ surfel ] = epsilon;
            }
        }
    }

References DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::epsilon, K, DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus, and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::smallest_epsilon_map.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence().

Field Documentation

◆ alpha

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

double DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha

The global coefficient alpha giving the smoothness of the reconstruction (the smaller, the smoother)

Definition at line 181 of file ATSolver2D.h.

◆ alpha_g2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

std::vector<PrimalForm2> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_g2

protected

The alpha-weighted N-array of input primal 2-forms g.

Definition at line 162 of file ATSolver2D.h.

◆ alpha_Id2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalIdentity2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::alpha_Id2

protected

The alpha-weighted identity operator for primal 2-forms (stored for performance)

Definition at line 156 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ dimension

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

const Dimension DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::dimension = KSpace::dimension

static

Definition at line 99 of file ATSolver2D.h.

◆ epsilon

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

double DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::epsilon

The global coefficient epsilon giving the width of the discontinuities (the smaller, the thinner)

Definition at line 187 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setEpsilon(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::updateSmallestEpsilonMap().

◆ former_v0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::former_v0

protected

The primal 0-form v at the previous iteration.

Definition at line 169 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::diffV0(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ g2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

std::vector<PrimalForm2> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::g2

protected

The N-array of input primal 2-forms g.

Definition at line 160 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp().

◆ l_1_over_4e

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::l_1_over_4e

protected

The primal 0-form lambda/(4epsilon) (stored for performance)

Definition at line 171 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setEpsilon(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ l_1_over_4e_Id0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalIdentity0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::l_1_over_4e_Id0

protected

The 1/(4epsilon)-weighted identity operator for primal 0-forms (stored for performance)

Definition at line 158 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setEpsilon(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ lambda

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

double DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::lambda

The global coefficient lambda giving the length of discontinuities (the smaller, the more discontinuities)

Definition at line 184 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setEpsilon(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ M01

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalDerivative0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M01

protected

The primal vertex to edge average operator.

Definition at line 150 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV1(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ M12

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalDerivative1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::M12

protected

The primal edge to face average operator.

Definition at line 152 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV2(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators().

◆ normalize_u2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

bool DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::normalize_u2

Indicates whether to normalize U (unit norm) at each iteration or not.

Definition at line 189 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ primal_AD2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalAntiderivative2 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::primal_AD2

protected

The antiderivative of primal 2-forms.

Definition at line 154 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ primal_D0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalDerivative0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::primal_D0

protected

the derivative operator for primal 0-forms

Definition at line 146 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ primal_D1

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalDerivative1 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::primal_D1

protected

the derivative operator for primal 1-forms

Definition at line 148 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initOperators().

◆ ptrCalculus

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

CountedConstPtrOrConstPtr< Calculus > DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ptrCalculus

protected

A smart (or not) pointer to a calculus object.

Definition at line 144 of file ATSolver2D.h.

◆ smallest_epsilon_map

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

SmallestEpsilonMap DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::smallest_epsilon_map

The map Surfel -> double telling the smallest epsilon for which the surfel was a discontinuity.

Definition at line 178 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveGammaConvergence(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::updateSmallestEpsilonMap().

◆ surfel2idx

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

Surfel2IndexMap DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::surfel2idx

Definition at line 175 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::ATSolver2D(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getOutputVectorFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputScalarFieldU2(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::initInputVectorFieldU2(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::setUp().

◆ u2

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

std::vector<PrimalForm2> DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::u2

protected

The N-array of regularized primal 2-forms u.

Definition at line 164 of file ATSolver2D.h.

◆ v0

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

PrimalForm0 DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::v0

protected

The primal 0-form v representing the set of discontinuities S (more precisely \( 1 - \chi_S \))

Definition at line 167 of file ATSolver2D.h.

Referenced by DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV0(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV1(), DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::getV2(), and DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::solveOneAlternateStep().

◆ verbose

template<typename TKSpace , typename TLinearAlgebra = EigenLinearAlgebraBackend>

int DGtal::ATSolver2D< TKSpace, TLinearAlgebra >::verbose

Tells the verbose level.

Definition at line 191 of file ATSolver2D.h.

The documentation for this class was generated from the following file:

ATSolver2D.h

Public Types

Public Member Functions

Data Fields

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ Calculus

◆ Cell

◆ Domain

◆ Index

◆ KSpace

◆ LinearAlgebra

◆ LinearAlgebraSolver

◆ PrimalAntiderivative1

◆ PrimalAntiderivative2

◆ PrimalDerivative0

◆ PrimalDerivative1

◆ PrimalForm0

◆ PrimalForm1

◆ PrimalForm2

◆ PrimalHodge0

◆ PrimalHodge1

◆ PrimalHodge2

◆ PrimalIdentity0

◆ PrimalIdentity1

◆ PrimalIdentity2

◆ RealVector

◆ Scalar

◆ SCell

◆ Self

◆ SmallestEpsilonMap

◆ SolverU2

◆ SolverV0

◆ Space

◆ Surfel

◆ Surfel2IndexMap

Member Enumeration Documentation

◆ CellOutputPolicy

Constructor & Destructor Documentation

◆ ATSolver2D() [1/4]

◆ ATSolver2D() [2/4]

◆ ~ATSolver2D()

◆ ATSolver2D() [3/4]

◆ ATSolver2D() [4/4]

Member Function Documentation

◆ checkV0()

◆ diffV0()

◆ getOutputScalarFieldU2()

◆ getOutputScalarFieldV0()

◆ getOutputVectorFieldU2()

◆ getU2()

◆ getV0()

◆ getV1()

◆ getV2()

◆ initInputScalarFieldU2() [1/2]

◆ initInputScalarFieldU2() [2/2]

◆ initInputVectorFieldU2() [1/2]

◆ initInputVectorFieldU2() [2/2]

◆ initOperators()

◆ isValid()

◆ normalizeU2()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ selfDisplay()

◆ setEpsilon()

◆ setUp() [1/3]

◆ setUp() [2/3]

◆ setUp() [3/3]

◆ size()

◆ solveForEpsilon()

◆ solveGammaConvergence()

◆ solveOneAlternateStep()

◆ updateSmallestEpsilonMap()

Field Documentation

◆ alpha

◆ alpha_g2

◆ alpha_Id2

◆ dimension