itkPreconditionedGradientDescentOptimizer.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkPreconditionedGradientDescentOptimizer_h
#define __itkPreconditionedGradientDescentOptimizer_h
 
#include "itkScaledSingleValuedNonLinearOptimizer.h"
#include "itkArray2D.h"
#include "vnl/vnl_sparse_matrix.h"
#include "cholmod.h"
 
namespace itk
{
class PreconditionedGradientDescentOptimizer :
  public ScaledSingleValuedNonLinearOptimizer
{
public:
  typedef PreconditionedGradientDescentOptimizer               Self;
  typedef ScaledSingleValuedNonLinearOptimizer    Superclass;
  typedef SmartPointer<Self>                Pointer;
  typedef SmartPointer<const Self>          ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro( PreconditionedGradientDescentOptimizer, ScaledSingleValuedNonLinearOptimizer );
 
  typedef Superclass::MeasureType               MeasureType;
  typedef Superclass::ParametersType            ParametersType;
  typedef Superclass::DerivativeType            DerivativeType;
  typedef Superclass::CostFunctionType          CostFunctionType;
  typedef Superclass::ScalesType                ScalesType;
  typedef Superclass::ScaledCostFunctionType    ScaledCostFunctionType;
  typedef Superclass::ScaledCostFunctionPointer ScaledCostFunctionPointer;
 
  typedef DerivativeType::ValueType                       PreconditionValueType;
  //typedef Array2D<PreconditionValueType>                  PreconditionType;
  //typedef vnl_symmetric_eigensystem<
  //  PreconditionValueType >                               EigenSystemType;
  typedef vnl_sparse_matrix< PreconditionValueType >      PreconditionType;
 
  typedef enum {
    MaximumNumberOfIterations,
    MetricError,
    MinimumStepSize } StopConditionType;
 
  virtual void AdvanceOneStep( void );
 
  virtual void StartOptimization( void );
 
  virtual void ResumeOptimization( void );
 
  virtual void MetricErrorResponse( ExceptionObject & err );
 
  virtual void StopOptimization( void );
 
  itkSetMacro( LearningRate, double );
 
  itkGetConstReferenceMacro( LearningRate, double);
 
  itkSetMacro( NumberOfIterations, unsigned long );
 
  itkGetConstReferenceMacro( NumberOfIterations, unsigned long );
 
  itkGetConstMacro( CurrentIteration, unsigned int );
 
  itkGetConstReferenceMacro( Value, double );
 
  itkGetConstReferenceMacro( StopCondition, StopConditionType );
 
  itkGetConstReferenceMacro( Gradient, DerivativeType );
 
  itkGetConstReferenceMacro( SearchDirection, DerivativeType );
 
  virtual void SetPreconditionMatrix( PreconditionType & precondition );
 
  const cholmod_common * GetCholmodCommon( void ) const
  {
    return this->m_CholmodCommon;
  }
 
 
  const cholmod_factor * GetCholmodFactor( void ) const
  {
    return this->m_CholmodFactor;
  }
 
  itkSetMacro( DiagonalWeight, double );
  itkGetConstMacro( DiagonalWeight, double );
 
  itkSetMacro( MinimumGradientElementMagnitude, double );
  itkGetConstMacro( MinimumGradientElementMagnitude, double );
 
  itkGetConstMacro( ConditionNumber, double );
 
  itkGetConstMacro( LargestEigenValue, double );
 
  itkGetConstMacro( Sparsity, double );
 
protected:
  PreconditionedGradientDescentOptimizer();
  virtual ~PreconditionedGradientDescentOptimizer();
 
  void PrintSelf(std::ostream& os, Indent indent) const;
 
  typedef int CInt; // change to UF_long if using cholmod_l;
 
  // made protected so subclass can access
  DerivativeType                m_Gradient;
  double                        m_LearningRate;
  StopConditionType             m_StopCondition;
  DerivativeType                m_SearchDirection;
  double                        m_LargestEigenValue;
  double                        m_ConditionNumber;
  double                        m_Sparsity;
 
  cholmod_common * m_CholmodCommon;
  cholmod_factor * m_CholmodFactor;
  cholmod_sparse * m_CholmodGradient;
 
  virtual void CholmodSolve( const DerivativeType & gradient,
    DerivativeType & searchDirection, int solveType = CHOLMOD_A );
 
private:
  PreconditionedGradientDescentOptimizer(const Self&); // purposely not implemented
  void operator=(const Self&); // purposely not implemented
 
  bool                          m_Stop;
  double                        m_Value;
 
  unsigned long                 m_NumberOfIterations;
  unsigned long                 m_CurrentIteration;
 
  double                        m_DiagonalWeight;
  double                        m_MinimumGradientElementMagnitude;
 
};
 
} // end namespace itk
 
 
#endif