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" 
//#include "DGtal/io/boards/Board2D.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:

  //DrawableWithBoard2D* defaultStyle( std::string mode = "" ) const;
  
  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)