mitkPixelTypeTraits.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 PIXELTYPETRAITS_H
#define PIXELTYPETRAITS_H

#include <itkDiffusionTensor3D.h>
#include <itkImage.h>
#include <itkImageIOBase.h>
#include <itkRGBAPixel.h>
#include <itkRGBPixel.h>
#include <itkVectorImage.h>

namespace itk
{
  template <typename TValueType>
  class VariableLengthVector;
}

#define MITK_PIXEL_COMPONENT_TYPE(type, ctype, name)                                                                   \
  template <>                                                                                                          \
  struct mitk::MapPixelComponentType<type>                                                                             \
  {                                                                                                                    \
    static const int value = ctype;                                                                                    \
  } template <>                                                                                                        \
  std::string mitk::PixelComponentTypeToString()                                                                       \
  {                                                                                                                    \
    return name;                                                                                                       \
  }

namespace mitk
{
  static const int PixelUserType = itk::ImageIOBase::MATRIX + 1;
  static const int PixelComponentUserType = itk::ImageIOBase::DOUBLE + 1;

  template <typename T>
  struct MapPixelComponentType
  {
    static const int value = itk::ImageIOBase::MapPixelType<T>::CType;
  };

  template <typename T>
  struct isPrimitiveType
  {
    static const bool value = false;
  };

#define DEFINE_TYPE_PRIMITIVE(_TYPEIN)                                                                                 \
  template <>                                                                                                          \
  struct isPrimitiveType<_TYPEIN>                                                                                      \
  {                                                                                                                    \
    static const bool value = true;                                                                                    \
  }

  DEFINE_TYPE_PRIMITIVE(unsigned char);
  DEFINE_TYPE_PRIMITIVE(char);
  DEFINE_TYPE_PRIMITIVE(signed char);
  DEFINE_TYPE_PRIMITIVE(unsigned short);
  DEFINE_TYPE_PRIMITIVE(short);
  DEFINE_TYPE_PRIMITIVE(unsigned int);
  DEFINE_TYPE_PRIMITIVE(int);
  DEFINE_TYPE_PRIMITIVE(long int);
  DEFINE_TYPE_PRIMITIVE(long unsigned int);
  DEFINE_TYPE_PRIMITIVE(float);
  DEFINE_TYPE_PRIMITIVE(double);

  template <typename TPixelType, unsigned int VDimension = 0>
  struct ImageTypeTrait
  {
    typedef itk::Image<TPixelType, VDimension> ImageType;
    static const bool IsVectorImage = false;
  };

  template <typename TPixelType, unsigned int VDimension>
  struct ImageTypeTrait<itk::VariableLengthVector<TPixelType>, VDimension>
  {
    typedef itk::VectorImage<TPixelType, VDimension> ImageType;
    static const bool IsVectorImage = true;
  };

  template <typename T>
  struct ImageTypeTrait<T, 0>
  {
    typedef T ImageType;
    static const bool IsVectorImage = false;
  };

  template <typename TPixelType, unsigned int VDimension>
  struct ImageTypeTrait<itk::VectorImage<TPixelType, VDimension>, 0>
  {
    typedef itk::VectorImage<TPixelType, VDimension> ImageType;
    static const bool IsVectorImage = true;
  };

  template <bool flag, typename T>
  struct PixelTypeTrait
  {
    typedef T ValueType;
  };

  template <typename T>
  struct PixelTypeTrait<false, T>
  {
    typedef typename T::ValueType ValueType;
  };

  template <typename T>
  struct GetComponentType
  {
    typedef typename PixelTypeTrait<isPrimitiveType<T>::value, T>::ValueType ComponentType;
  };

  template <bool V, typename T>
  struct ComponentsTrait
  {
    static const size_t Size = 1;
  };

  template <typename T>
  struct ComponentsTrait<false, T>
  {
    static const size_t Size = T::ValueType::Length;
  };

  typedef itk::ImageIOBase::IOPixelType itkIOPixelType;

  template <class T>
  struct MapCompositePixelType
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::UNKNOWNPIXELTYPE;
  };

  //------------------------
  // Partial template specialization for fixed-length types
  //------------------------

  template <class C>
  struct MapCompositePixelType<itk::RGBPixel<C>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::RGB;
  };

  template <class C>
  struct MapCompositePixelType<itk::RGBAPixel<C>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::RGBA;
  };

  template <class C>
  struct MapCompositePixelType<itk::DiffusionTensor3D<C>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::DIFFUSIONTENSOR3D;
  };

  template <class C>
  struct MapCompositePixelType<itk::VariableLengthVector<C>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::VECTOR;
  };

  //------------------------
  // Partial template specialization for variable-length types
  //------------------------
  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::Vector<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::VECTOR;
  };

  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::FixedArray<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::COVARIANTVECTOR;
  };

  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::CovariantVector<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::COVARIANTVECTOR;
  };

  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::Matrix<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itk::ImageIOBase::MATRIX;
  };

  template <class T, bool Primitive>
  struct MapPixelType
  {
    static const itkIOPixelType IOPixelType = MapCompositePixelType<T>::IOCompositeType;
    static const int IOComponentType = MapPixelComponentType<typename GetComponentType<T>::ComponentType>::value;
  };

  template <class T>
  struct MapPixelType<T, true>
  {
    static const itkIOPixelType IOPixelType = itk::ImageIOBase::SCALAR;
    static const int IOComponentType = MapPixelComponentType<T>::value;
  };

} // end namespace mitk

#endif // PIXELTYPETRAITS_H