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::ImageIOBase::IOPixelType ItkIOPixelType;
    typedef itk::ImageIOBase::IOComponentType ItkIOComponentType;

    PixelType(const mitk::PixelType &aPixelType);
    PixelType &operator=(const PixelType &other);

    itk::ImageIOBase::IOPixelType GetPixelType() const;

    int 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 numberOfComponents);

    template <typename ItkImageType>
    friend PixelType MakePixelType();

    template <typename ItkImageType>
    friend PixelType MakePixelType(size_t);

    PixelType(const int componentType,
              const ItkIOPixelType pixelType,
              std::size_t bytesPerComponent,
              std::size_t numberOfComponents,
              const std::string &componentTypeName,
              const std::string &pixelTypeName);

    // default constructor is disabled on purpose
    PixelType(void);

    int 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 /* mitkPixelType_h */