AngleLinearMinimizer.h

 
#pragma once
 
#if defined(AngleLinearMinimizer_RECURSES)
#error Recursive header files inclusion detected in AngleLinearMinimizer.h
#else // defined(AngleLinearMinimizer_RECURSES)
#define AngleLinearMinimizer_RECURSES
 
#if !defined AngleLinearMinimizer_h
#define AngleLinearMinimizer_h
 
// Inclusions
#include <iostream>
#include <vector>
#include "DGtal/base/Common.h"
#include "DGtal/math/AngleComputer.h" 
#include "DGtal/arithmetic/ModuloComputer.h" 
 
namespace DGtal
{
 
// class AngleLinearMinimizer
class AngleLinearMinimizer
{
  
public:
  struct ValueInfo
  {
    double value;
 
    double oldValue; 
    
    double min;
 
    double max;
 
    double distToNext;
    
  };
  
 
 
    // ----------------------- Standard services ------------------------------
public:
  
  virtual ~AngleLinearMinimizer();
  
  AngleLinearMinimizer();
  
  void reset();
 
  void init( unsigned int nbMax );
  
 
   ValueInfo & rw( unsigned int i );
 
  
   const ValueInfo & ro( unsigned int i ) const;
  
   unsigned int maxSize() const;
 
   unsigned int size() const;
 
   void setSize( unsigned int nb );
 
   void setIsCurveOpen( bool is_curve_open = false );
 
 
 
  
  // ------------------------- Optimization services --------------------------
 
public:
  
  double getEnergy( unsigned int i1, unsigned int i2 ) const;
  
  double getFormerEnergy( unsigned int i1, unsigned int i2 ) const;  
  
  
  std::vector<double> getGradient() const;
 
 
  std::vector<double> getFormerGradient() const;
  
  double optimize();
  
  
  double optimize( unsigned int i1, unsigned int i2 );
  
  
   double sum() const;
 
 
 
   double max() const;
 
 
protected:
 
  virtual void oneStep( unsigned int i1, unsigned int i2 );
 
 
public:
  virtual double lastDelta() const; 
 
 
 
 
 
    // --------------- CDrawableWithBoard2D realization -------------------
  public:
 
  std::string className() const;
 
  // ----------------------- Interface --------------------------------------
public:
 
  
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
 
    // ------------------------- Protected Datas ------------------------------
 
protected:
  bool myIsCurveOpen;
  
  ValueInfo* myValues;
  
  unsigned int mySize;
 
private:
  
  unsigned int myMaxSize;
 
 
    // ------------------------- Private Datas --------------------------------
private:
  double mySum;
  
  double myMax;
 
  // ------------------------- Hidden services ------------------------------
 
  
 
private:
   AngleLinearMinimizer( const AngleLinearMinimizer & other );
   AngleLinearMinimizer & operator=( const AngleLinearMinimizer & other );
  
 
  
  // ------------------------- Internals ------------------------------------
private:
 
}; // end of class AngleLinearMinimizer
 
 
 
 
  class AngleLinearMinimizerByRelaxation : public AngleLinearMinimizer
  {
  public:
     AngleLinearMinimizerByRelaxation();
 
     virtual ~AngleLinearMinimizerByRelaxation();
 
  protected:
    
    virtual void oneStep( unsigned int i1, unsigned int i2 );
 
public:
    virtual double lastDelta() const; 
 
    // ----------------------- Interface --------------------------------------
  public:
    virtual void selfDisplay( std::ostream & aStream ) const;
 
  };
  
 
 
  class AngleLinearMinimizerByGradientDescent : public AngleLinearMinimizer
  {
  private:
 
    double myStep;
 
  public:
     AngleLinearMinimizerByGradientDescent( double step = 0.1 );
 
     virtual ~AngleLinearMinimizerByGradientDescent();
 
  protected:
    
    virtual void oneStep( unsigned int i1, unsigned int i2 );
 
public:
    virtual double lastDelta() const; 
 
    // ----------------------- Interface --------------------------------------
  public:
    virtual void selfDisplay( std::ostream & aStream ) const;
 
  };
 
 
  class AngleLinearMinimizerByAdaptiveStepGradientDescent : public AngleLinearMinimizer
  {
  private:
 
    double myStep;
 
  public:
     AngleLinearMinimizerByAdaptiveStepGradientDescent( double step = 0.1 );
 
     virtual ~AngleLinearMinimizerByAdaptiveStepGradientDescent();
 
  protected:
    
    virtual void oneStep( unsigned int i1, unsigned int i2 );
 
public:
    virtual double lastDelta() const; 
 
    // ----------------------- Interface --------------------------------------
  public:
    virtual void selfDisplay( std::ostream & aStream ) const;
 
  };
  
  
 
 
std::ostream&
operator<< ( std::ostream & out, const AngleLinearMinimizer & object );
 
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/math/AngleLinearMinimizer.ih"
 
//                                                                           //
 
#endif // !defined AngleLinearMinimizer_h
 
#undef AngleLinearMinimizer_RECURSES
#endif // else defined(AngleLinearMinimizer_RECURSES)