DGtal::dec_helper Namespace Reference

Namespace for functions useful to Discrete Exterior Calculus package. More...

Functions
template<typename Calculus , DGtal::Dimension dim, DGtal::Duality duality>
DGtal::LinearOperator< Calculus, dim, duality, dim, duality >	diagonal (const DGtal::KForm< Calculus, dim, duality > &kform)
template<typename Calculus >
DGtal::LinearOperator< Calculus, 0, DGtal::PRIMAL, 1, DGtal::PRIMAL >	averageOperator01 (const Calculus &calculus)
template<typename Calculus >
DGtal::LinearOperator< Calculus, 1, DGtal::PRIMAL, 2, DGtal::PRIMAL >	averageOperator01 (const Calculus &calculus)
template<typename Calculus >
DGtal::LinearOperator< Calculus, 2, DGtal::PRIMAL, 0, DGtal::PRIMAL >	averageOperator20 (const Calculus &calculus)

Detailed Description

Namespace for functions useful to Discrete Exterior Calculus package.

Function Documentation

averageOperator01() [1/2]

template<typename Calculus >

DGtal::LinearOperator<Calculus, 0, DGtal::PRIMAL, 1, DGtal::PRIMAL> DGtal::dec_helper::averageOperator01

(

const Calculus &

calculus

)

Builds the linear operator that brings a primal 0-form to a primal 1-form by averaging (vertex to edge operator)

Parameters

calculus

any discrete calculus

Definition at line 82 of file DECHelpers.h.

    {
      auto M01        = calculus.template derivative<0,DGtal::PRIMAL>();
      M01.myContainer = 0.5 * M01.myContainer.cwiseAbs();
      return M01;
    }

References calculus.

averageOperator01() [2/2]

template<typename Calculus >

DGtal::LinearOperator<Calculus, 1, DGtal::PRIMAL, 2, DGtal::PRIMAL> DGtal::dec_helper::averageOperator01

(

const Calculus &

calculus

)

Builds the linear operator that brings a primal 1-form to a primal 2-form by averaging (edge to face operator)

Parameters

calculus

any discrete calculus

Definition at line 95 of file DECHelpers.h.

    {
      auto M12        = calculus.template derivative<1,DGtal::PRIMAL>();
      M12.myContainer = 0.25 * M12.myContainer.cwiseAbs();
      return M12;
    }

References calculus.

averageOperator20()

template<typename Calculus >

DGtal::LinearOperator<Calculus, 2, DGtal::PRIMAL, 0, DGtal::PRIMAL> DGtal::dec_helper::averageOperator20

(

const Calculus &

calculus

)

Builds the linear operator that brings a primal 2-form to a primal 0-form by averaging (face to vertex operator)

Parameters

calculus

a discrete calculus over a 2D digital surface in 3D.

Definition at line 108 of file DECHelpers.h.

    {
      BOOST_STATIC_ASSERT( Calculus::dimensionEmbedded == 2 );
      BOOST_STATIC_ASSERT( Calculus::dimensionAmbient == 3 );
      using DGtal::PRIMAL;
      using DGtal::DUAL;
      
      typedef typename Calculus::LinearAlgebraBackend::SparseMatrix SparseMatrix;
      typedef typename Calculus::LinearAlgebraBackend::Triplet Triplet;
      typedef typename Calculus::KSpace KSpace;
      typedef typename Calculus::Index Index;
      typedef typename Calculus::Cell Cell;
      typedef typename Calculus::Scalar Scalar;
      typedef typename Calculus::Point Point;
      typedef DGtal::LinearOperator<Calculus, 2, DGtal::PRIMAL, 0, DGtal::PRIMAL>
        Operator;
      
      const KSpace& kspace = calculus.myKSpace;
 
      const std::vector<Point> deltas = {
        Point(0,1,1), Point(0,-1,1), Point(0,-1,-1), Point(0,1,-1),
        Point(1,0,1), Point(-1,0,1), Point(-1,0,-1), Point(1,0,-1),
        Point(1,1,0), Point(-1,1,0), Point(-1,-1,0), Point(1,-1,0)
      };
      
      std::vector<Triplet> triplets;
      for (Index index_point=0; index_point<calculus.kFormLength(0,PRIMAL); index_point++)
        {
          const Cell point = kspace.unsigns(calculus.getSCell(0, PRIMAL, index_point));
          ASSERT( kspace.uDim(point) == 0 );
          
          std::vector<Index> indexes_surfel;
          for (const Point delta : deltas)
            {
              const Cell surfel = kspace.uCell((kspace.uKCoords(point)+delta));
              ASSERT( kspace.uDim(surfel) == 2 );
              if (calculus.containsCell(surfel))
                indexes_surfel.push_back(calculus.getCellIndex(surfel));
            }
          ASSERT( indexes_surfel.size() > 2 );
          
          const double weight = 1/static_cast<Scalar>(indexes_surfel.size());
          for (const Index index_surfel : indexes_surfel)
            triplets.emplace_back( index_point, index_surfel, weight );
        }
      
      SparseMatrix matrix( calculus.kFormLength(0, DGtal::PRIMAL),
                           calculus.kFormLength(2, DGtal::PRIMAL) );
      matrix.setFromTriplets(triplets.begin(), triplets.end());
      
      return Operator(calculus, matrix);
    }

References calculus, DGtal::DUAL, DGtal::PRIMAL, DGtal::KhalimskySpaceND< dim, TInteger >::uCell(), DGtal::KhalimskySpaceND< dim, TInteger >::uDim(), DGtal::KhalimskySpaceND< dim, TInteger >::uKCoords(), and DGtal::KhalimskySpaceND< dim, TInteger >::unsigns().

diagonal()

template<typename Calculus , DGtal::Dimension dim, DGtal::Duality duality>

DGtal::LinearOperator<Calculus, dim, duality, dim, duality> DGtal::dec_helper::diagonal

(

const DGtal::KForm< Calculus, dim, duality > &

kform

)

Builds a linear diagonal operator from a k-form. Corresponds to Diag(v) if v is a vector.

Parameters

kform

any k-dimensional form.

Returns

the corresponding diagonal linear operator.

Definition at line 60 of file DECHelpers.h.

    {
      typedef DGtal::LinearOperator<Calculus,dim, duality, dim, duality> Operator;
      typedef typename Calculus::LinearAlgebraBackend::Triplet Triplet;
      typedef typename Calculus::Index Index;
      typedef std::vector<Triplet> Triplets;
 
      Triplets triplets;
      for (Index index=0; index<kform.length(); index++)
        triplets.emplace_back( index, index, kform.myContainer(index) );
      Operator ope(kform.myCalculus);
      ope.myContainer.setFromTriplets(triplets.begin(), triplets.end());
      
      return ope;
    }

References DGtal::KForm< TCalculus, order, duality >::length(), DGtal::KForm< TCalculus, order, duality >::myCalculus, and DGtal::KForm< TCalculus, order, duality >::myContainer.

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