mitkPixelType.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 mitkPixelType_h
#define mitkPixelType_h
 
#include <mitkCommon.h>
#include <mitkPixelTypeTraits.h>
#include <MitkCoreExports.h>
 
#include <string>
#include <typeinfo>
 
#include <itkImage.h>
#include <itkImageIOBase.h>
#include <vtkImageData.h>
 
namespace mitk
{
  template <typename T>
  std::string PixelComponentTypeToString()
  {
    return itk::ImageIOBase::GetComponentTypeAsString(itk::ImageIOBase::MapPixelType<T>::CType);
  }
 
  template <typename PixelT>
  std::string PixelTypeToString()
  {
    return std::string();
  }
 
  class MITKCORE_EXPORT PixelType
  {
  public:
    typedef itk::IOPixelEnum ItkIOPixelType;      
    typedef itk::IOComponentEnum ItkIOComponentType; 
 
    PixelType(const mitk::PixelType &aPixelType);
 
    PixelType &operator=(const PixelType &other);
 
    ItkIOPixelType GetPixelType() const;
 
    ItkIOComponentType GetComponentType() const;
 
    std::string GetPixelTypeAsString() const;
 
    std::string GetComponentTypeAsString() const;
 
    std::string GetTypeAsString() const;
 
    size_t GetSize() const;
 
    size_t GetBpe() const;
 
    size_t GetNumberOfComponents() const;
 
    size_t GetBitsPerComponent() const;
 
    bool operator==(const PixelType &rhs) const;
 
    bool operator!=(const PixelType &rhs) const;
 
    ~PixelType();
 
  private:
    friend PixelType MakePixelType(const itk::ImageIOBase *imageIO);
 
    template <typename ComponentT, typename PixelT>
    friend PixelType MakePixelType(std::size_t numOfComponents);
 
    template <typename ItkImageType>
    friend PixelType MakePixelType();
 
    template <typename ItkImageType>
    friend PixelType MakePixelType(size_t);
 
    PixelType(ItkIOComponentType componentType,
              ItkIOPixelType pixelType,
              std::size_t bytesPerComponent,
              std::size_t numOfComponents,
              const std::string &componentTypeName,
              const std::string &pixelTypeName);
 
    // default constructor is disabled on purpose
    PixelType(void);
 
    ItkIOComponentType m_ComponentType;
 
    ItkIOPixelType m_PixelType;
 
    std::string m_ComponentTypeName;
 
    std::string m_PixelTypeName;
 
    std::size_t m_NumberOfComponents;
 
    std::size_t m_BytesPerComponent;
  };
 
  MITKCORE_EXPORT mitk::PixelType MakePixelType(vtkImageData *vtkimagedata);
 
  template <typename ComponentT, typename PixelT>
  PixelType MakePixelType(std::size_t numOfComponents)
  {
    return PixelType(MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOComponentType,
                     MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOPixelType,
                     sizeof(ComponentT),
                     numOfComponents,
                     PixelComponentTypeToString<ComponentT>(),
                     PixelTypeToString<PixelT>());
  }
 
  template <typename ComponentT, typename PixelT, std::size_t numOfComponents>
  PixelType MakePixelType()
  {
    return MakePixelType<ComponentT, PixelT>(numOfComponents);
  }
 
  template <typename ItkImageType>
  struct AssertImageTypeIsValid
  {
  };
 
  // The itk::VariableLengthVector pixel type is not supported in MITK if it is
  // used with an itk::Image (it cannot be represented as a mitk::Image object).
  // Use a itk::VectorImage instead.
  template <typename TPixelType, unsigned int VImageDimension>
  struct AssertImageTypeIsValid<itk::Image<itk::VariableLengthVector<TPixelType>, VImageDimension>>;
 
  template <typename ItkImageType>
  PixelType MakePixelType(std::size_t numOfComponents)
  {
    AssertImageTypeIsValid<ItkImageType>();
 
    // define new type, since the ::PixelType is used to distinguish between simple and compound types
    typedef typename ItkImageType::PixelType ImportPixelType;
 
    // get the component type ( is either directly ImportPixelType or ImportPixelType::ValueType for compound types )
    typedef typename GetComponentType<ImportPixelType>::ComponentType ComponentT;
 
    // The PixelType is the same as the ComponentT for simple types
    typedef typename ItkImageType::PixelType PixelT;
 
    // call the constructor
    return PixelType(MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOComponentType,
                     MapPixelType<PixelT, isPrimitiveType<PixelT>::value>::IOPixelType,
                     sizeof(ComponentT),
                     numOfComponents,
                     PixelComponentTypeToString<ComponentT>(),
                     PixelTypeToString<PixelT>());
  }
 
  template <typename TPixelType, unsigned int VImageDimension>
  PixelType MakePixelType(std::size_t numOfComponents)
  {
    typedef typename ImageTypeTrait<TPixelType, VImageDimension>::ImageType ItkImageType;
    return MakePixelType<ItkImageType>(numOfComponents);
  }
 
  template <typename ItkImageType>
  PixelType MakePixelType()
  {
    if (ImageTypeTrait<ItkImageType>::IsVectorImage)
    {
      mitkThrow() << " Variable pixel type given but the length is not specified. Use the parametric MakePixelType( "
                     "size_t ) method instead.";
    }
 
    // Use the InternalPixelType to get "1" for the number of components in case of
    // a itk::VectorImage
    typedef typename ItkImageType::InternalPixelType PixelT;
 
    const std::size_t numComp = ComponentsTrait<isPrimitiveType<PixelT>::value, ItkImageType>::Size;
 
    // call the constructor
    return MakePixelType<ItkImageType>(numComp);
  }
 
  inline PixelType MakePixelType(const itk::ImageIOBase *imageIO)
  {
    return mitk::PixelType(imageIO->GetComponentType(),
                           imageIO->GetPixelType(),
                           imageIO->GetComponentSize(),
                           imageIO->GetNumberOfComponents(),
                           imageIO->GetComponentTypeAsString(imageIO->GetComponentType()),
                           imageIO->GetPixelTypeAsString(imageIO->GetPixelType()));
  }
 
  template <typename T>
  PixelType MakeScalarPixelType()
  {
    return MakePixelType<T, T, 1>();
  }
 
} // namespace mitk
 
#endif