mitkAbstractClassifier.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
 
#ifndef mitkAbstractClassifier_h
#define mitkAbstractClassifier_h
 
#include <MitkCLCoreExports.h>
 
 
#include <mitkBaseData.h>
 
// Eigen
#include <Eigen/Dense>
 
// STD Includes
 
// MITK includes
#include <mitkConfigurationHolder.h>
 
namespace mitk
{
class MITKCLCORE_EXPORT AbstractClassifier : public BaseData
{
public:
 
  mitkClassMacro(AbstractClassifier,BaseData);
 
  virtual void Train(const Eigen::MatrixXd &X, const Eigen::MatrixXi &Y) = 0;
 
  virtual Eigen::MatrixXi Predict(const Eigen::MatrixXd &X) = 0;
 
  Eigen::MatrixXi & GetLabels()
  {
    return m_OutLabel;
  }
 
protected:
  Eigen::MatrixXi m_OutLabel;
 
 
public:
  // * --------------- *
  // PointWiseWeight
  // * --------------- *
 
  virtual bool SupportsPointWiseWeight() = 0;
 
  virtual Eigen::MatrixXd & GetPointWiseWeight()
  {
    return m_PointWiseWeight;
  }
 
  virtual void SetPointWiseWeight(const Eigen::MatrixXd& W)
  {
    this->m_PointWiseWeight = W;
  }
 
  virtual void UsePointWiseWeight(bool value)
  {
    this->m_IsUsingPointWiseWeight = value;
  }
 
  virtual bool IsUsingPointWiseWeight()
  {
    return this->m_IsUsingPointWiseWeight;
  }
 
protected:
  Eigen::MatrixXd m_PointWiseWeight;
  bool m_IsUsingPointWiseWeight;
 
  // * --------------- *
  // PointWiseProbabilities
  // * --------------- *
 
public:
  virtual bool SupportsPointWiseProbability() = 0;
 
  virtual Eigen::MatrixXd & GetPointWiseProbabilities()
  {
    return m_OutProbability;
  }
 
  virtual void UsePointWiseProbability(bool value)
  {
    m_IsUsingPointWiseProbability = value;
  }
 
  virtual bool IsUsingPointWiseProbability()
  {
    return m_IsUsingPointWiseProbability;
  }
 
protected:
  Eigen::MatrixXd m_OutProbability;
  bool m_IsUsingPointWiseProbability;
 
private:
  void MethodForBuild();
 
public:
 
 
  void SetNthItems(const char *val, unsigned int idx);
  std::string GetNthItems(unsigned int idx) const;
 
  void SetItemList(std::vector<std::string>);
  std::vector<std::string> GetItemList() const;
 
#ifndef DOXYGEN_SKIP
 
  void SetRequestedRegionToLargestPossibleRegion() override{}
  bool RequestedRegionIsOutsideOfTheBufferedRegion() override{return true;}
  bool VerifyRequestedRegion() override{return false;}
 
  void SetRequestedRegion(const itk::DataObject* /*data*/) override{}
 
 
  // Override
  bool IsEmpty() const override
  {
    if(IsInitialized() == false)
      return true;
    const TimeGeometry* timeGeometry = const_cast<AbstractClassifier*>(this)->GetUpdatedTimeGeometry();
    if(timeGeometry == nullptr)
      return true;
    return false;
  }
 
#endif // Skip Doxygen
 
};
}
 
#endif