stop iterating based on the gain which is (oldChi - currentChi) / currentChi. More...

#include <sparse_optimizer_terminate_action.h>

Inheritance diagram for g2o::SparseOptimizerTerminateAction:

Collaboration diagram for g2o::SparseOptimizerTerminateAction:

Public Member Functions
	SparseOptimizerTerminateAction ()

virtual HyperGraphAction *	operator() (const HyperGraph graph, Parameters parameters=0)

double	gainThreshold () const

void	setGainThreshold (double gainThreshold)

int	maxIterations () const

void	setMaxIterations (int maxit)

Public Member Functions inherited from g2o::HyperGraphAction
virtual	~HyperGraphAction ()

Protected Member Functions
void	setOptimizerStopFlag (const SparseOptimizer *optimizer, bool stop)

Protected Attributes
double	_gainThreshold

double	_lastChi

bool	_auxTerminateFlag

int	_maxIterations

Detailed Description

stop iterating based on the gain which is (oldChi - currentChi) / currentChi.

stop iterating based on the gain which is (oldChi - currentChi) / currentChi. If the gain is larger than zero and below the threshold, then the optimizer is stopped. Typically usage of this action includes adding it as a postIteration action, by calling addPostIterationAction on a sparse optimizer.

Definition at line 19 of file sparse_optimizer_terminate_action.h.

Constructor & Destructor Documentation

g2o::SparseOptimizerTerminateAction::SparseOptimizerTerminateAction ( )

Definition at line 9 of file sparse_optimizer_terminate_action.cpp.

                                                                  :
     HyperGraphAction(),
     _gainThreshold(1e-6), _lastChi(0.), _auxTerminateFlag(false),
     _maxIterations(std::numeric_limits<int>::max())
   {
   }

Member Function Documentation

double g2o::SparseOptimizerTerminateAction::gainThreshold ( ) const

inline

Definition at line 25 of file sparse_optimizer_terminate_action.h.

Referenced by setGainThreshold().

25 { return _gainThreshold;}

g2o::SparseOptimizerTerminateAction::_gainThreshold

double _gainThreshold

Definition: sparse_optimizer_terminate_action.h:32

int g2o::SparseOptimizerTerminateAction::maxIterations ( ) const

inline

Definition at line 28 of file sparse_optimizer_terminate_action.h.

28 { return _maxIterations;}

g2o::SparseOptimizerTerminateAction::_maxIterations

int _maxIterations

Definition: sparse_optimizer_terminate_action.h:35

HyperGraphAction * g2o::SparseOptimizerTerminateAction::operator()	(	const HyperGraph *	graph,
		Parameters *	parameters = `0`
	)

virtual

re-implement to carry out an action given the graph

Reimplemented from g2o::HyperGraphAction.

Definition at line 21 of file sparse_optimizer_terminate_action.cpp.

References _gainThreshold, _lastChi, _maxIterations, g2o::SparseOptimizer::activeRobustChi2(), graph, g2o::HyperGraphAction::ParametersIteration::iteration, and setOptimizerStopFlag().

   {
     assert(dynamic_cast<const SparseOptimizer*>(graph) && "graph is not a SparseOptimizer");
     assert(dynamic_cast<HyperGraphAction::ParametersIteration*>(parameters) && "error casting parameters");
 
     const SparseOptimizer* optimizer = static_cast<const SparseOptimizer*>(graph);
     HyperGraphAction::ParametersIteration* params = static_cast<HyperGraphAction::ParametersIteration*>(parameters);
 
     const_cast<SparseOptimizer*>(optimizer)->computeActiveErrors();
     if (params->iteration < 0)
     {
       // let the optimizer run for at least one iteration
       // Hence, we reset the stop flag
       setOptimizerStopFlag(optimizer, false);
     } else if (params->iteration == 0) {
       // first iteration, just store the chi2 value
       _lastChi = optimizer->activeRobustChi2();
     } else {
       // compute the gain and stop the optimizer in case the
       // gain is below the threshold or we reached the max
       // number of iterations
       bool stopOptimizer = false;
       if (params->iteration < _maxIterations) {
         double currentChi = optimizer->activeRobustChi2();
         double gain = (_lastChi - currentChi) / currentChi;
         _lastChi = currentChi;
         if (gain >= 0 && gain < _gainThreshold)
           stopOptimizer = true;
       } else {
         stopOptimizer = true;
       }
       if (stopOptimizer) { // tell the optimizer to stop
         setOptimizerStopFlag(optimizer, true);
       }
     }
     return this;
   }

void g2o::SparseOptimizerTerminateAction::setGainThreshold ( double gainThreshold )

Definition at line 16 of file sparse_optimizer_terminate_action.cpp.

References _gainThreshold, and gainThreshold().

Referenced by main().

   {
     _gainThreshold = gainThreshold;
   }

void g2o::SparseOptimizerTerminateAction::setMaxIterations ( int maxit )

Definition at line 59 of file sparse_optimizer_terminate_action.cpp.

References _maxIterations.

Referenced by main().

   {
     _maxIterations = maxit;
   }

void g2o::SparseOptimizerTerminateAction::setOptimizerStopFlag	(	const SparseOptimizer *	optimizer,
		bool	stop
	)

protected

Definition at line 64 of file sparse_optimizer_terminate_action.cpp.

References _auxTerminateFlag, and g2o::SparseOptimizer::forceStopFlag().

Referenced by operator()().

   {
     if (optimizer->forceStopFlag()) {
       *(optimizer->forceStopFlag()) = stop;
     } else {
       _auxTerminateFlag = stop;
       const_cast<SparseOptimizer*>(optimizer)->setForceStopFlag(&_auxTerminateFlag);
     }
   }