otbSVMModel.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt for details.


     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __otbSVMModel_h
#define __otbSVMModel_h

#include "itkObjectFactory.h"
#include "itkDataObject.h"
#include "itkVariableLengthVector.h"
#include "svm.h"
#include "itkTimeProbe.h"

namespace otb
{

template <class TValue, class TLabel>
class ITK_EXPORT SVMModel : public itk::DataObject
{
public:
  typedef SVMModel                      Self;
  typedef itk::DataObject               Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  typedef TValue ValueType;
  typedef TLabel                                LabelType;
  typedef std::vector<ValueType>                MeasurementType;
  typedef std::pair<MeasurementType, LabelType> SampleType;
  typedef std::vector<SampleType>               SamplesVectorType;
  typedef std::vector<struct svm_node *> CacheVectorType;

  typedef itk::VariableLengthVector<double> ProbabilitiesVectorType;
  typedef itk::VariableLengthVector<double> DistancesVectorType;

  typedef struct svm_node * NodeCacheType;

  itkNewMacro(Self);
  itkTypeMacro(SVMModel, itk::DataObject);

  unsigned int GetNumberOfClasses(void) const
  {
    return (unsigned int) (m_Model->nr_class);
  }

  unsigned int GetNumberOfHyperplane(void) const
  {
    return (unsigned int) (m_Model->nr_class * (m_Model->nr_class - 1) / 2);
  }

  void SetModel(struct svm_model* aModel);

  const struct svm_model* GetModel()
  {
    return m_Model;
  }

  struct svm_parameter& GetParameters()
  {
    return m_Parameters;
  }
  const struct svm_parameter& GetParameters() const
  {
    return m_Parameters;
  }

  void SaveModel(const char* model_file_name) const;
  void SaveModel(const std::string& model_file_name) const
  {
    //implemented in term of const char * version
    this->SaveModel(model_file_name.c_str());
  }

  void LoadModel(const char* model_file_name);
  void LoadModel(const std::string& model_file_name)
  {
    //implemented in term of const char * version
    this->LoadModel(model_file_name.c_str());
  }

  Pointer GetCopy() const;

  void SetSVMType(int svmtype)
  {
    m_Parameters.svm_type = svmtype;
    this->Modified();
  }

  int GetSVMType(void) const
  {
    return m_Parameters.svm_type;
  }

  void SetKernelType(int kerneltype)
  {
    m_Parameters.kernel_type = kerneltype;
    this->Modified();
  }

  int GetKernelType(void) const
  {
    return m_Parameters.kernel_type;
  }

  void SetPolynomialKernelDegree(int degree)
  {
    m_Parameters.degree = degree;
    this->Modified();
  }

  int GetPolynomialKernelDegree(void) const
  {
    return m_Parameters.degree;
  }

  virtual void SetKernelGamma(double gamma)
  {
    m_Parameters.gamma = gamma;
    this->Modified();
  }
  double GetKernelGamma(void) const
  {
    return m_Parameters.gamma;
  }

  void SetKernelCoef0(double coef0)
  {
    m_Parameters.coef0 = coef0;
    this->Modified();
  }

  double GetKernelCoef0(void) const
  {
    //return m_Parameters.coef0;
    return m_Parameters.coef0;
  }

  void SetNu(double nu)
  {
    m_Parameters.nu = nu;
    this->Modified();
  }

  double GetNu(void) const
  {
    //return m_Parameters.nu;
    return m_Parameters.nu;
  }

  void SetCacheSize(int cSize)
  {
    m_Parameters.cache_size = static_cast<double>(cSize);
    this->Modified();
  }

  int GetCacheSize(void) const
  {
    return static_cast<int>(m_Parameters.cache_size);
  }

  void SetC(double c)
  {
    m_Parameters.C = c;
    this->Modified();
  }

  double GetC(void) const
  {
    return m_Parameters.C;
  }

  void SetEpsilon(double eps)
  {
    m_Parameters.eps = eps;
    this->Modified();
  }

  double GetEpsilon(void) const
  {
    return m_Parameters.eps;
  }

  /* Set the value of p for EPSILON_SVR */
  void SetP(double p)
  {
    m_Parameters.p = p;
    this->Modified();
  }

  /* Get the value of p for EPSILON_SVR */
  double GetP(void) const
  {
    return m_Parameters.p;
  }

  void DoShrinking(bool s)
  {
    m_Parameters.shrinking = static_cast<int>(s);
    this->Modified();
  }

  bool GetDoShrinking(void) const
  {
    return static_cast<bool>(m_Parameters.shrinking);
  }

  void DoProbabilityEstimates(bool prob)
  {
    m_Parameters.probability = static_cast<int>(prob);
    this->Modified();
  }

  bool GetDoProbabilityEstimates(void) const
  {
    return static_cast<bool>(m_Parameters.probability);
  }

  GenericKernelFunctorBase * GetKernelFunctor(void) const
  {
    return m_Parameters.kernel_generic;
  }

  void SetKernelFunctor(GenericKernelFunctorBase* pGenericKernelFunctor)
  {
    if (pGenericKernelFunctor != NULL)
      m_Parameters.kernel_generic = pGenericKernelFunctor->Clone();
    this->Modified();
  }

  int GetNumberOfSupportVectors(void) const
  {
    return m_Model->l;
  }

  double * GetRho(void) const
  {
    return m_Model->rho;
  }
  svm_node ** GetSupportVectors(void)
  {
    return m_Model->SV;
  }
  void SetSupportVectors(svm_node ** sv, int nbOfSupportVector);

  double ** GetAlpha(void)
  {
    return m_Model->sv_coef;
  }
  void SetAlpha(double ** alpha, int nbOfSupportVector);

  int * GetLabels()
  {
    return m_Model->label;
  }

  int * GetNumberOfSVPerClasse()
  {
    return m_Model->nSV;
  }

  struct svm_problem& GetProblem()
  {
    return m_Problem;
  }

  virtual void Modified()
  {
    Superclass::Modified();
    m_ModelUpToDate = false;
  }

  void BuildProblem();

  void ConsistencyCheck();

  void Train();

  double CrossValidation(unsigned int nbFolders);

  LabelType EvaluateLabel(const MeasurementType& measure) const;

  DistancesVectorType EvaluateHyperplanesDistances(const MeasurementType& measure) const;

  ProbabilitiesVectorType EvaluateProbabilities(const MeasurementType& measure) const;

  void AddSample(const MeasurementType& measure, const LabelType& label);

  void ClearSamples();

  void SetSamples(const SamplesVectorType& samples);

  void Reset();

protected:
  SVMModel();
  virtual ~SVMModel();
  void PrintSelf(std::ostream& os, itk::Indent indent) const;

  void DeleteProblem();

  void DeleteModel();

  void Initialize();

private:
  SVMModel(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented

  struct svm_model* m_Model;

  bool m_ModelUpToDate;

  struct svm_problem m_Problem;

  struct svm_parameter m_Parameters;

  bool m_ProblemUpToDate;

  SamplesVectorType m_Samples;
}; // class SVMModel

} // namespace otb

#ifndef OTB_MANUAL_INSTANTIATION
#include "otbSVMModel.txx"
#endif

#endif