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