mitkAbstractGlobalImageFeature.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 mitkAbstractGlobalImageFeature_h
#define mitkAbstractGlobalImageFeature_h

#include <MitkCLCoreExports.h>

#include <mitkBaseData.h>
#include <mitkImage.h>

#include <mitkCommandLineParser.h>

#include <mitkIntensityQuantifier.h>

// STD Includes

// Eigen
#include <Eigen/Dense>

// MITK includes
#include <mitkConfigurationHolder.h>

namespace mitk
{
class MITKCLCORE_EXPORT AbstractGlobalImageFeature : public BaseData
{
public:
  mitkClassMacro(AbstractGlobalImageFeature, BaseData);

  typedef std::vector< std::pair<std::string, double> > FeatureListType;
  typedef std::vector< std::string>                     FeatureNameListType;
  typedef std::map<std::string, us::Any>                ParameterTypes;

  virtual FeatureListType CalculateFeatures(const Image::Pointer & feature, const Image::Pointer &mask) = 0;

  FeatureListType CalculateFeaturesSlicewise(const Image::Pointer & feature, const Image::Pointer &mask, int sliceID);

  virtual void CalculateFeaturesSliceWiseUsingParameters(const Image::Pointer & feature, const Image::Pointer &mask, int sliceID, FeatureListType &featureList);

  virtual void CalculateFeaturesUsingParameters(const Image::Pointer & feature, const Image::Pointer &mask, const Image::Pointer &maskNoNAN, FeatureListType &featureList) = 0;

  virtual FeatureNameListType GetFeatureNames() = 0;

  virtual std::string GetCurrentFeatureEncoding();

  std::string FeatureDescriptionPrefix();

  itkSetMacro(Prefix, std::string);
  itkSetMacro(ShortName, std::string);
  itkSetMacro(LongName, std::string);
  itkSetMacro(FeatureClassName, std::string);
  itkSetMacro(Direction, int);
  void SetParameter(ParameterTypes param) { m_Parameter=param; };

  itkGetConstMacro(Prefix, std::string);
  itkGetConstMacro(ShortName, std::string);
  itkGetConstMacro(LongName, std::string);
  itkGetConstMacro(FeatureClassName, std::string);
  itkGetConstMacro(Parameter, ParameterTypes);

  itkSetMacro(UseQuantifier, bool);
  itkGetConstMacro(UseQuantifier, bool);
  itkSetMacro(Quantifier, IntensityQuantifier::Pointer);
  itkGetMacro(Quantifier, IntensityQuantifier::Pointer);

  itkGetConstMacro(Direction, int);

  itkSetMacro(MinimumIntensity, double);
  itkSetMacro(UseMinimumIntensity, bool);
  itkSetMacro(MaximumIntensity, double);
  itkSetMacro(UseMaximumIntensity, bool);
  itkGetConstMacro(MinimumIntensity, double);
  itkGetConstMacro(UseMinimumIntensity, bool);
  itkGetConstMacro(MaximumIntensity, double);
  itkGetConstMacro(UseMaximumIntensity, bool);


  itkSetMacro(Binsize, double);
  itkSetMacro(UseBinsize, bool);
  itkGetConstMacro(Binsize, double);
  itkGetConstMacro(UseBinsize, bool);

  itkSetMacro(MorphMask, mitk::Image::Pointer);
  itkGetConstMacro(MorphMask, mitk::Image::Pointer);

  itkSetMacro(Bins, int);
  itkSetMacro(UseBins, bool);
  itkGetConstMacro(UseBins, bool);
  itkGetConstMacro(Bins, int);

  itkSetMacro(IgnoreMask, bool);
  itkGetConstMacro(IgnoreMask, bool);

  itkSetMacro(EncodeParameters, bool);
  itkGetConstMacro(EncodeParameters, bool);

  std::string GetOptionPrefix() const
  {
    if (m_Prefix.length() > 0)
      return m_Prefix + "::" + m_ShortName;
    return m_ShortName;

  }

  virtual void AddArguments(mitkCommandLineParser &parser) = 0;
  std::vector<double> SplitDouble(std::string str, char delimiter);

  void AddQuantifierArguments(mitkCommandLineParser &parser);
  void InitializeQuantifierFromParameters(const Image::Pointer & feature, const Image::Pointer &mask,unsigned int defaultBins = 256);
  void InitializeQuantifier(const Image::Pointer & feature, const Image::Pointer &mask, unsigned int defaultBins = 256);
  std::string QuantifierParameterString();

public:

//#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<AbstractGlobalImageFeature*>(this)->GetUpdatedTimeGeometry();
    if(timeGeometry == nullptr)
      return true;
    return false;
  }


private:
  std::string m_Prefix; // Prefix before all input parameters
  std::string m_ShortName; // Name of all variables
  std::string m_LongName; // Long version of the name (For turning on)
  std::string m_FeatureClassName;
  ParameterTypes m_Parameter; // Parameter setting

  bool m_UseQuantifier = false;
  IntensityQuantifier::Pointer m_Quantifier;

  double m_MinimumIntensity = 0;
  bool m_UseMinimumIntensity = false;
  double m_MaximumIntensity = 100;
  bool m_UseMaximumIntensity = false;
  bool m_EncodeParameters = false;

  double m_Binsize = 1;
  bool m_UseBinsize = false;

  int m_Bins = 256;
  bool m_UseBins = true;
  int m_Direction = 0;

  bool m_IgnoreMask = false;
  bool m_CalculateWithParameter = false;

  mitk::Image::Pointer m_MorphMask = nullptr;
//#endif // Skip Doxygen

};
}

#endif //mitkAbstractGlobalImageFeature_h