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
{
 
  struct MITKCLCORE_EXPORT FeatureID
  {
    std::string name;
    std::string featureClass;
    std::string settingID;
    std::string legacyName;
    std::string version = "1";
 
    using ParametersType = std::map<std::string, us::Any>;
    ParametersType parameters;
 
    bool operator < (const FeatureID& rh) const;
    bool operator ==(const FeatureID& rh) const;
  };
 
  MITKCLCORE_EXPORT FeatureID CreateFeatureID(FeatureID templateID, std::string name);
 
class MITKCLCORE_EXPORT AbstractGlobalImageFeature : public BaseData
{
public:
  mitkClassMacro(AbstractGlobalImageFeature, BaseData);
 
  typedef std::vector< std::pair<FeatureID, double> > FeatureListType;
  using ParametersType = FeatureID::ParametersType;
 
  FeatureListType CalculateFeatures(const Image* image, const Image* mask);
  virtual FeatureListType CalculateFeatures(const Image* image, const Image* mask, const Image* maskNoNAN) = 0;
 
  FeatureListType CalculateFeaturesSlicewise(const Image::Pointer & image, const Image::Pointer &mask, int sliceID);
 
  virtual void CalculateAndAppendFeaturesSliceWise(const Image::Pointer & image, const Image::Pointer &mask, int sliceID, FeatureListType &featureList, bool checkParameterActivation = true);
 
  void CalculateAndAppendFeatures(const Image* image, const Image* mask, const Image* maskNoNaN, FeatureListType &featureList, bool checkParameterActivation = true);
 
  itkSetMacro(Prefix, std::string);
  itkSetMacro(ShortName, std::string);
  itkSetMacro(LongName, std::string);
  itkSetMacro(FeatureClassName, std::string);
  itkSetMacro(Direction, int);
 
  void SetParameters(ParametersType param)
  {
    m_Parameters = param;
    this->ConfigureQuantifierSettingsByParameters();
    this->ConfigureSettingsByParameters(param);
    this->Modified();
  };
 
  itkGetConstMacro(Prefix, std::string);
  itkGetConstMacro(ShortName, std::string);
  itkGetConstMacro(LongName, std::string);
  itkGetConstMacro(FeatureClassName, std::string);
  itkGetConstMacro(Parameters, ParametersType);
 
  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(EncodeParametersInFeaturePrefix, bool);
  itkGetConstMacro(EncodeParametersInFeaturePrefix, bool);
  itkBooleanMacro(EncodeParametersInFeaturePrefix);
 
  std::string GetOptionPrefix() const
  {
    if (!m_Prefix.empty())
      return m_Prefix + "::" + m_ShortName;
    return m_ShortName;
  }
 
  virtual void AddArguments(mitkCommandLineParser &parser) const = 0;
 
  static std::string GenerateLegacyFeatureNameWOEncoding(const FeatureID& id);
 
protected:
  std::vector<double> SplitDouble(std::string str, char delimiter);
 
  virtual FeatureListType DoCalculateFeatures(const Image* image, const Image* mask) = 0;
 
  void AddQuantifierArguments(mitkCommandLineParser& parser) const;
 
  void ConfigureQuantifierSettingsByParameters();
 
  virtual void ConfigureSettingsByParameters(const ParametersType& parameters);
 
  void InitializeQuantifier(const Image* image, const Image* mask, unsigned int defaultBins = 256);
 
  std::string QuantifierParameterString() const;
 
  /* Creates a template feature id.
   * it will set the featureClass, the settingID (assuming that it is the featureClass with the passed suffix
   * and all parameters that are global or have the option prefix of the instance.*/
  FeatureID CreateTemplateFeatureID(std::string settingsSuffix = "", FeatureID::ParametersType additionalParams = {});
 
  virtual std::string GenerateLegacyFeatureName(const FeatureID& id) const;
  virtual std::string GenerateLegacyFeatureNamePart(const FeatureID& id) const;
  virtual std::string GenerateLegacyFeatureEncoding(const FeatureID& id) const;
 
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;
  ParametersType m_Parameters; // Parameter setting
 
  mitk::Image::Pointer m_MorphMask = nullptr;
 
 
  IntensityQuantifier::Pointer m_Quantifier;
  //Quantifier relevant variables
  double m_MinimumIntensity = 0;
  bool m_UseMinimumIntensity = false;
  double m_MaximumIntensity = 100;
  bool m_UseMaximumIntensity = false;
  bool m_EncodeParametersInFeaturePrefix = 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;
//#endif // Skip Doxygen
 
};
}
 
#endif