itkL2RegularizedLeastSquaresSolver.h

Go to the documentation of this file.

#ifndef __itkL2RegularizedLeastSquaresSolver_h
#define __itkL2RegularizedLeastSquaresSolver_h

#include "vnl/vnl_matrix.h"
#include "itkSolverBase.h"


namespace itk
{

template <class TPrecision>
class ITK_EXPORT L2RegularizedLeastSquaresSolver : public SolverBase<TPrecision>
{
public:
  typedef L2RegularizedLeastSquaresSolver         Self;
  typedef SolverBase<TPrecision>                  Superclass;
  typedef SmartPointer<Self>                            Pointer;
  typedef SmartPointer<const Self>                      ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro( L2RegularizedLeastSquaresSolver, SolverBase );

  typedef typename Superclass::ValueType       ValueType;
  typedef typename Superclass::MatrixType      MatrixType;
  typedef typename Superclass::VectorType      VectorType;
  typedef typename Superclass::MatrixPointer   MatrixPointer;
  typedef typename Superclass::VectorPointer   VectorPointer;

  typedef typename Superclass::ValueContainerType ValueContainerType;

  void SetA(const MatrixPointer& mat);
  itkGetMacro(A, MatrixPointer);
  void SetLambda(const MatrixPointer& mat);
  itkGetMacro(Lambda, MatrixPointer);
  itkSetMacro(b, VectorPointer);
  itkGetMacro(b, VectorPointer);
  
  itkGetMacro(LS, MatrixPointer);
  itkGetMacro(ConditionNumber, ValueType);

  int GetXDimension() const ITK_OVERRIDE
    {
    int N = m_A->Columns();
    utlException(N==0, "wrong size! m_A->Columns()="<<m_A->Columns());
    return N;
    }

  void Clear() ITK_OVERRIDE;
  void ClearA() 
    { 
    m_A=MatrixPointer(new MatrixType()); 
    m_LS=MatrixPointer(new MatrixType());
    m_ConditionNumber=-1;
    }
  void ClearLambda() 
    { 
    m_Lambda=MatrixPointer(new MatrixType()); 
    m_LS=MatrixPointer(new MatrixType()); 
    m_ConditionNumber=-1;
    m_IsLambdaSymmetric = true;
    }
  void Clearb() 
    { 
    m_b=VectorPointer(new VectorType()); 
    }

  void VerifyInputs() const ITK_OVERRIDE;
  
  void Solve(const VectorType& xInitial=VectorType()) ITK_OVERRIDE; 
  void Initialize(const VectorType& xInitial=VectorType()) ITK_OVERRIDE; 
  
  ValueType EvaluateCostFunction(const VectorType& x=VectorType()) const ITK_OVERRIDE;

protected:
  L2RegularizedLeastSquaresSolver();
  virtual ~L2RegularizedLeastSquaresSolver() {};

  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
  
  virtual typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;
  
  MatrixPointer m_A;
  VectorPointer m_b;
  
  MatrixPointer m_Lambda;

  bool m_IsLambdaSymmetric;
  

private:
  L2RegularizedLeastSquaresSolver(const Self&);  //purposely not implemented
  void operator=(const Self&);  //purposely not implemented
  
  MatrixPointer m_LS;
  ValueType m_ConditionNumber;

};

}

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkL2RegularizedLeastSquaresSolver+-.h"
#endif

#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkL2RegularizedLeastSquaresSolver_hxx)
#include "itkL2RegularizedLeastSquaresSolver.hxx"
#endif


#endif