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 mitkPixelTypeTraits_h
#define mitkPixelTypeTraits_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 = static_cast<int>(itk::IOPixelEnum::MATRIX) + 1;
 
  static const int PixelComponentUserType = static_cast<int>(itk::IOComponentEnum::DOUBLE) + 1;
 
  template <typename T>
  struct MapPixelComponentType
  {
    static const itk::IOComponentEnum 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::IOPixelEnum itkIOPixelType;
 
  typedef itk::IOComponentEnum itkIOComponentType;
 
  template <class T>
  struct MapCompositePixelType
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::UNKNOWNPIXELTYPE;
  };
 
  //------------------------
  // Partial template specialization for fixed-length types
  //------------------------
 
  template <class C>
  struct MapCompositePixelType<itk::RGBPixel<C>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::RGB;
  };
 
  template <class C>
  struct MapCompositePixelType<itk::RGBAPixel<C>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::RGBA;
  };
 
  template <class C>
  struct MapCompositePixelType<itk::DiffusionTensor3D<C>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::DIFFUSIONTENSOR3D;
  };
 
  template <class C>
  struct MapCompositePixelType<itk::VariableLengthVector<C>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::VECTOR;
  };
 
  //------------------------
  // Partial template specialization for variable-length types
  //------------------------
  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::Vector<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::VECTOR;
  };
 
  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::FixedArray<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::COVARIANTVECTOR;
  };
 
  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::CovariantVector<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::COVARIANTVECTOR;
  };
 
  template <class C, unsigned int N>
  struct MapCompositePixelType<itk::Matrix<C, N>>
  {
    static const itkIOPixelType IOCompositeType = itkIOPixelType::MATRIX;
  };
 
  template <class T, bool Primitive>
  struct MapPixelType
  {
    static const itkIOPixelType IOPixelType = MapCompositePixelType<T>::IOCompositeType;
    static const itkIOComponentType IOComponentType = MapPixelComponentType<typename GetComponentType<T>::ComponentType>::value;
  };
 
  template <class T>
  struct MapPixelType<T, true>
  {
    static const itkIOPixelType IOPixelType = itkIOPixelType::SCALAR;
    static const itkIOComponentType IOComponentType = MapPixelComponentType<T>::value;
  };
 
} // end namespace mitk
 
#endif