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 //mitkAbstractClassifier_h