elxConfiguration.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef elxConfiguration_h
#define elxConfiguration_h
 
#include "itkObject.h"
#include "elxBaseComponent.h"
 
#include "itkParameterFileParser.h"
#include "itkParameterMapInterface.h"
#include <map>
#include "xoutmain.h"
 
namespace elastix
{
 
class Configuration
  : public itk::Object
  , public BaseComponent
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(Configuration);
 
  using Self = Configuration;
  using Superclass1 = itk::Object;
  using Superclass2 = BaseComponent;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(Configuration, itk::Object);
 
  using CommandLineArgumentMapType = std::map<std::string, std::string>;
  using CommandLineEntryType = CommandLineArgumentMapType::value_type;
 
  std::string
  GetCommandLineArgument(const std::string & key) const;
 
  void
  SetCommandLineArgument(const std::string & key, const std::string & value);
 
  itkGetStringMacro(ParameterFileName);
  itkSetStringMacro(ParameterFileName);
 
  virtual int
  Initialize(const CommandLineArgumentMapType & _arg);
 
  virtual int
  Initialize(const CommandLineArgumentMapType & _arg, const itk::ParameterFileParser::ParameterMapType & inputMap);
 
  virtual bool
  IsInitialized() const; // to elxconfigurationbase
 
  itkSetMacro(ElastixLevel, unsigned int);
  itkGetConstMacro(ElastixLevel, unsigned int);
 
  itkSetMacro(TotalNumberOfElastixLevels, unsigned int);
  itkGetConstMacro(TotalNumberOfElastixLevels, unsigned int);
 
  /***/
  virtual bool
  GetPrintErrorMessages()
  {
    return this->m_ParameterMapInterface->GetPrintErrorMessages();
  }
 
 
  int
  BeforeAll() override;
 
  virtual int
  BeforeAllTransformix();
 
  std::size_t
  CountNumberOfParameterEntries(const std::string & parameterName) const
  {
    return this->m_ParameterMapInterface->CountNumberOfParameterEntries(parameterName);
  }
 
 
  template <class T>
  bool
  ReadParameter(T &                 parameterValue,
                const std::string & parameterName,
                const unsigned int  entry_nr,
                const bool          printThisErrorMessage) const
  {
    std::string errorMessage = "";
    bool        found = this->m_ParameterMapInterface->ReadParameter(
      parameterValue, parameterName, entry_nr, printThisErrorMessage, errorMessage);
    if (!errorMessage.empty())
    {
      xl::xout["error"] << errorMessage;
    }
 
    return found;
  }
 
 
  template <class T>
  bool
  ReadParameter(T & parameterValue, const std::string & parameterName, const unsigned int entry_nr) const
  {
    std::string errorMessage = "";
    bool found = this->m_ParameterMapInterface->ReadParameter(parameterValue, parameterName, entry_nr, errorMessage);
    if (!errorMessage.empty())
    {
      xl::xout["error"] << errorMessage;
    }
 
    return found;
  }
 
 
  template <class T>
  bool
  ReadParameter(T &                 parameterValue,
                const std::string & parameterName,
                const std::string & prefix,
                const unsigned int  entry_nr,
                const int           default_entry_nr,
                const bool          printThisErrorMessage) const
  {
    std::string errorMessage = "";
    bool        found = this->m_ParameterMapInterface->ReadParameter(
      parameterValue, parameterName, prefix, entry_nr, default_entry_nr, printThisErrorMessage, errorMessage);
    if (!errorMessage.empty())
    {
      xl::xout["error"] << errorMessage;
    }
 
    return found;
  }
 
 
  template <class T>
  bool
  ReadParameter(T &                 parameterValue,
                const std::string & parameterName,
                const std::string & prefix,
                const unsigned int  entry_nr,
                const int           default_entry_nr) const
  {
    std::string errorMessage = "";
    bool        found = this->m_ParameterMapInterface->ReadParameter(
      parameterValue, parameterName, prefix, entry_nr, default_entry_nr, errorMessage);
    if (!errorMessage.empty())
    {
      xl::xout["error"] << errorMessage;
    }
 
    return found;
  }
 
 
  bool
  HasParameter(const std::string & parameterName) const
  {
    return m_ParameterMapInterface->HasParameter(parameterName);
  }
 
 
  std::vector<std::string>
  GetValuesOfParameter(const std::string & parameterName) const
  {
    return m_ParameterMapInterface->GetValues(parameterName);
  }
 
 
  template <typename T>
  std::unique_ptr<std::vector<T>>
  RetrieveValuesOfParameter(const std::string & parameterName) const
  {
    return m_ParameterMapInterface->RetrieveValues<T>(parameterName);
  }
 
  template <typename T>
  T
  RetrieveParameterValue(const T &           defaultParameterValue,
                         const std::string & parameterName,
                         const unsigned int  entry_nr,
                         const bool          printThisErrorMessage) const
  {
    auto parameterValue = defaultParameterValue;
    (void)Self::ReadParameter<T>(parameterValue, parameterName, entry_nr, printThisErrorMessage);
    return parameterValue;
  }
 
 
  std::string
  RetrieveParameterStringValue(const std::string & defaultParameterValue,
                               const std::string & parameterName,
                               const unsigned int  entry_nr,
                               const bool          printThisErrorMessage) const
  {
    return Self::RetrieveParameterValue(defaultParameterValue, parameterName, entry_nr, printThisErrorMessage);
  }
 
 
  template <class T>
  bool
  ReadParameter(std::vector<T> &    parameterValues,
                const std::string & parameterName,
                const unsigned int  entry_nr_start,
                const unsigned int  entry_nr_end,
                const bool          printThisErrorMessage) const
  {
    std::string errorMessage = "";
    bool        found = this->m_ParameterMapInterface->ReadParameter(
      parameterValues, parameterName, entry_nr_start, entry_nr_end, printThisErrorMessage, errorMessage);
    if (!errorMessage.empty())
    {
      xl::xout["error"] << errorMessage;
    }
 
    return found;
  }
 
 
protected:
  Configuration();
  ~Configuration() override = default;
 
  virtual void
  PrintParameterFile() const;
 
private:
  CommandLineArgumentMapType          m_CommandLineArgumentMap{};
  std::string                         m_ParameterFileName{};
  itk::ParameterFileParser::Pointer   m_ParameterFileParser{ itk::ParameterFileParser::New() };
  itk::ParameterMapInterface::Pointer m_ParameterMapInterface{ itk::ParameterMapInterface::New() };
 
  bool         m_IsInitialized{ false };
  unsigned int m_ElastixLevel{ 0 };
  unsigned int m_TotalNumberOfElastixLevels{ 1 };
};
 
} // end namespace elastix
 
#endif // end #ifndef elxConfiguration_h