DigitalSurfaceRegularization.h

 
#pragma once
 
#if defined(DigitalSurfaceRegularization_RECURSES)
#error Recursive header files inclusion detected in DigitalSurfaceRegularization.h
#else // defined(DigitalSurfaceRegularization_RECURSES)
#define DigitalSurfaceRegularization_RECURSES
 
#if !defined DigitalSurfaceRegularization_h
#define DigitalSurfaceRegularization_h
 
// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConstAlias.h"
#include "DGtal/topology/DigitalSurface.h"
 
#include "DGtal/helpers/StdDefs.h"
#include "DGtal/helpers/Shortcuts.h"
#include "DGtal/helpers/ShortcutsGeometry.h"
 
namespace DGtal
  {
  
  // template class DigitalSurfaceRegularization
  template <typename TDigitalSurface>
  class DigitalSurfaceRegularization
  {
    // ----------------------- Standard services ------------------------------
  public:
    
    typedef TDigitalSurface DigSurface;
    typedef typename TDigitalSurface::DigitalSurfaceContainer DigitalSurfaceContainer;
    BOOST_CONCEPT_ASSERT(( concepts::CDigitalSurfaceContainer< DigitalSurfaceContainer > ));
    
    typedef Shortcuts<Z3i::KSpace> SH3;
    
    typedef ShortcutsGeometry<Z3i::KSpace> SHG3;
    
    typedef std::vector<Z3i::RealPoint> Positions;
    
    typedef std::vector<Z3i::RealVector> Normals;
    
    DigitalSurfaceRegularization(CountedPtr<DigSurface> aDigSurf)
    :  myInit(false), myVerbose(false), myDigitalSurface(aDigSurf)
    {
      myK = SH3::getKSpace( myDigitalSurface );
    }
    
    ~DigitalSurfaceRegularization() = default;
    
    DigitalSurfaceRegularization ( const DigitalSurfaceRegularization & other ) = delete;
    
    DigitalSurfaceRegularization ( DigitalSurfaceRegularization && other ) = delete;
    
    DigitalSurfaceRegularization & operator= ( const DigitalSurfaceRegularization & other ) = delete;
    
    DigitalSurfaceRegularization & operator= ( DigitalSurfaceRegularization && other ) = delete;
    
    // ----------------------- Interface --------------------------------------
  public:
    
    void attachNormalVectors(const std::function<SHG3::RealVector(SH3::SCell&)> &normalFunc);
    
    void attachConvolvedTrivialNormalVectors(const Parameters someParams
                                    = SH3::defaultParameters() | SHG3::defaultParameters() );
    
    
    void init(const double alpha = 0.001,
              const double beta  = 1.0,
              const double gamma = 0.05);
    
    
    void init(ConstAlias< std::vector<double> > alphas,
              ConstAlias< std::vector<double> > betas,
              ConstAlias< std::vector<double> > gammas);
    
    
    double computeGradient();
    
    
    double computeGradientLocalWeights();
    
    
    template <typename AdvectionFunction>
    double regularize(const unsigned int nbIters,
                      const double dt,
                      const double epsilon,
                      const AdvectionFunction & advectionFunc);
       double regularize(const unsigned int nbIters = 200,
                         const double dt = 1.0,
                         const double epsilon = 0.0001)
       {
         return regularize(nbIters,dt,epsilon,
                           [](SHG3::RealPoint& p,SHG3::RealPoint& o,SHG3::RealVector& v){ (void)o; p += v; });
       }
      
    
   
    static void clampedAdvection(SHG3::RealPoint &p,
                                 const SHG3::RealPoint &orig,
                                 const SHG3::RealVector &v)
    {
      p += v;
      for(auto i=0; i < 3; ++i)
        if ((p[i]-orig[i])> 0.5) p[i]=orig[i]+0.5;
        else
          if ((p[i]-orig[i])< -0.5) p[i]=orig[i]-0.5;
    }
    
    
    SHG3::RealPoint getRegularizedPosition(const SH3::Cell& aPointel)
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      ASSERT_MSG(myK.uDim(aPointel) == 0, "The cell must be a pointel (0-cell)");
      return myRegularizedPositions[ myPointelIndex[ aPointel] ];
    }
    
    const Positions & getRegularizedPositions() const
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      return myRegularizedPositions;
    }
    const Positions & getOriginalPositions() const
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      return myOriginalPositions;
    }
    const SH3::Cell2Index & getCellIndex() const
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      return myPointelIndex;
    }
    const Normals & getNormalVectors() const
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      return myNormals;
    }
    
    const SH3::Surfel2Index & getSurfelIndex() const
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      return mySurfelIndex;
    }
    
    void reset()
    {
      ASSERT_MSG(myInit, "The init() method must be called first.");
      std::copy(myOriginalPositions.begin(), myOriginalPositions.end(), myRegularizedPositions.begin());
    }
    
    
    // ----------------------- Services --------------------------------------
    
    
    void selfDisplay ( std::ostream & out ) const;
    
    bool isValid() const;
    
    void enableVerbose() {myVerbose=true;}
    
    void disasbleVerbose() {myVerbose=false;}
    
    // ------------------------- Private methods --------------------------------
  private:
    
    void cacheInit();
    
    
    // ------------------------- Private Datas --------------------------------
  private:
    
    double myAlpha;
    double myBeta;
    double myGamma;
    
    const std::vector<double> *myAlphas;
    const std::vector<double> *myBetas;
    const std::vector<double> *myGammas;
    
    bool myConstantCoeffs;
    
    bool myInit;
    
    bool myVerbose;
    
    CountedPtr<DigSurface> myDigitalSurface;
    
    Positions myOriginalPositions;
    
    Positions myRegularizedPositions;
    
    Normals myNormals;
    
    Positions myGradient;
    
    
  
    // ---------------------------------------------------------------
    
    Positions myGradientAlign;
    
    SH3::KSpace myK;
    
    SH3::SurfelRange mySurfels;
    
    SH3::Surfel2Index mySurfelIndex;
    
    SH3::Cell2Index myPointelIndex;
    
    std::vector< SH3::Idx > myAlignPointelsIdx;
    std::vector< SH3::Cell > myAlignPointels;
    std::vector<unsigned char> myNumberAdjEdgesToPointel;
    std::vector< SH3::Idx > myFairnessPointelsIdx;
    std::vector< unsigned char > myNbAdjacent;
    SH3::PolygonalSurface::FaceRange myFaces;
    
  }; // end of class DigitalSurfaceRegularization
  
  
  template <typename T>
  std::ostream&
  operator<< ( std::ostream & out, const DigitalSurfaceRegularization<T> & object );
  
  } // namespace surfaces
 
 
// Includes inline functions/methods if necessary.
#include "DGtal/geometry/surfaces/DigitalSurfaceRegularization.ih"
//                                                                           //
 
#endif // !defined DigitalSurfaceRegularization_h
 
#undef DigitalSurfaceRegularization_RECURSES
#endif // else defined(DigitalSurfaceRegularization_RECURSES)