itkTransformIOBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 itkTransformIOBase_h
#define itkTransformIOBase_h
 
#include "ITKIOTransformBaseExport.h"
 
#include "itkLightProcessObject.h"
#include "itkTransformBase.h"
#include "itkCommonEnums.h"
#include <list>
#include <iostream>
#include <fstream>
#include <string>
 
#ifndef ITKIOTransformBase_TEMPLATE_EXPORT
#  if defined(ITK_TEMPLATE_VISIBILITY_DEFAULT) || defined(__linux__) && defined(ITK_BUILD_SHARED_LIBS)
// Make everything visible
#    define ITKIOTransformBase_TEMPLATE_EXPORT __attribute__((visibility("default")))
#  else
#    define ITKIOTransformBase_TEMPLATE_EXPORT
#  endif
#endif
 
namespace itk
{
 
template <typename TParametersValueType>
class ITKIOTransformBase_TEMPLATE_EXPORT TransformIOBaseTemplate : public LightProcessObject
{
public:
  using Self = TransformIOBaseTemplate;
  using Superclass = LightProcessObject;
  using Pointer = SmartPointer<Self>;
 
  itkOverrideGetNameOfClassMacro(TransformIOBaseTemplate);
 
  using ScalarType = TParametersValueType; // For backwards compatibility
  using ParametersValueType = TParametersValueType;
  using FixedParametersValueType = double;
 
  using TransformType = TransformBaseTemplate<ParametersValueType>;
 
  using TransformPointer = typename TransformType::Pointer;
  using TransformListType = std::list<TransformPointer>;
  using ConstTransformPointer = typename TransformType::ConstPointer;
  using ConstTransformListType = std::list<ConstTransformPointer>;
 
  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);
  virtual void
  Read() = 0;
 
  virtual void
  Write() = 0;
 
  virtual bool
  CanReadFile(const char *) = 0;
 
  virtual bool
  CanWriteFile(const char *) = 0;
 
  TransformListType &
  GetTransformList()
  {
    return m_ReadTransformList;
  }
  TransformListType &
  GetReadTransformList()
  {
    return m_ReadTransformList;
  }
  ConstTransformListType &
  GetWriteTransformList()
  {
    return m_WriteTransformList;
  }
  void
  SetTransformList(ConstTransformListType & transformList);
 
  itkSetMacro(AppendMode, bool);
  itkGetConstMacro(AppendMode, bool);
  itkBooleanMacro(AppendMode);
  itkSetMacro(UseCompression, bool);
  itkGetConstMacro(UseCompression, bool);
  itkBooleanMacro(UseCompression);
  static inline void
  CorrectTransformPrecisionType(std::string & itkNotUsed(inputTransformName))
  {
    itkGenericExceptionMacro("Unknown ScalarType" << typeid(ScalarType).name());
  }
 
protected:
  TransformIOBaseTemplate();
  ~TransformIOBaseTemplate() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  OpenStream(std::ofstream & outputStream, bool binary);
 
  void
  CreateTransform(TransformPointer & ptr, const std::string & ClassName);
 
  /* The following struct returns the string name of computation type */
  /* default implementation */
  static inline std::string
  GetTypeNameString()
  {
    itkGenericExceptionMacro("Unknown ScalarType" << typeid(ScalarType).name());
  }
 
private:
  std::string            m_FileName{};
  TransformListType      m_ReadTransformList{};
  ConstTransformListType m_WriteTransformList{};
  bool                   m_AppendMode{ false };
  bool m_UseCompression{ false };
};
 
 
template <>
inline void
TransformIOBaseTemplate<float>::CorrectTransformPrecisionType(std::string & inputTransformName)
{
  // output precision type is not found in input transform.
  if (inputTransformName.find("float") == std::string::npos)
  {
    const std::string::size_type begin = inputTransformName.find("double");
    inputTransformName.replace(begin, 6, "float");
  }
}
 
template <>
inline void
TransformIOBaseTemplate<double>::CorrectTransformPrecisionType(std::string & inputTransformName)
{
  // output precision type is not found in input transform.
  if (inputTransformName.find("double") == std::string::npos)
  {
    const std::string::size_type begin = inputTransformName.find("float");
    inputTransformName.replace(begin, 5, "double");
  }
}
 
template <>
inline std::string
TransformIOBaseTemplate<float>::GetTypeNameString()
{
  return std::string("float");
}
 
template <>
inline std::string
TransformIOBaseTemplate<double>::GetTypeNameString()
{
  return std::string("double");
}
 
using TransformIOBase = itk::TransformIOBaseTemplate<double>;
 
} // end namespace itk
 
#endif // itkTransformIOBase_h
 
#ifndef ITK_TEMPLATE_EXPLICIT_TransformIOBase
// Explicit instantiation is required to ensure correct dynamic_cast
// behavior across shared libraries.
//
// IMPORTANT: Since within the same compilation unit,
//            ITK_TEMPLATE_EXPLICIT_<classname> defined and undefined states
//            need to be considered. This code *MUST* be *OUTSIDE* the header
//            guards.
//
#if defined(ITKIOTransformBase_EXPORTS)
//   We are building this library
#  define ITKIOTransformBase_EXPORT_EXPLICIT ITK_FORWARD_EXPORT
#else
//   We are using this library
#  define ITKIOTransformBase_EXPORT_EXPLICIT ITKIOTransformBase_EXPORT
#endif
namespace itk
{
 
ITK_GCC_PRAGMA_DIAG_PUSH()
ITK_GCC_PRAGMA_DIAG(ignored "-Wattributes")
 
extern template class ITKIOTransformBase_EXPORT_EXPLICIT TransformIOBaseTemplate<double>;
extern template class ITKIOTransformBase_EXPORT_EXPLICIT TransformIOBaseTemplate<float>;
 
ITK_GCC_PRAGMA_DIAG_POP()
 
} // end namespace itk
#undef ITKIOTransformBase_EXPORT_EXPLICIT
#endif