mitkAbstractClassifier.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

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


#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

  virtual void SetRequestedRegionToLargestPossibleRegion(){}
  virtual bool RequestedRegionIsOutsideOfTheBufferedRegion(){return true;}
  virtual bool VerifyRequestedRegion(){return false;}

  virtual void SetRequestedRegion(const itk::DataObject* /*data*/){}


  // Override
  virtual bool IsEmpty() const override
  {
    if(IsInitialized() == false)
      return true;
    const TimeGeometry* timeGeometry = const_cast<AbstractClassifier*>(this)->GetUpdatedTimeGeometry();
    if(timeGeometry == NULL)
      return true;
    return false;
  }

#endif // Skip Doxygen

};
}

#endif //mitkAbstractClassifier_h