#define CLITKIMAGECONVERTGENERICFILTER_CXX
#include "clitkImageConvertGenericFilter.h"
-// itk include
-#include "itkCastImageFilter.h"
-#include "itkVectorCastImageFilter.h"
//--------------------------------------------------------------------
clitk::ImageConvertGenericFilter::ImageConvertGenericFilter():
clitk::ImageToImageGenericFilter<Self>("ImageConvert")
{
mOutputPixelTypeName = "NotSpecified";
- mWarningOccur = false;
- mWarning = "";
mDisplayWarning = true;
+ mWarning = "";
+ mWarningOccur = false;
+
InitializeImageType<2>();
InitializeImageType<3>();
InitializeImageType<4>();
void clitk::ImageConvertGenericFilter::InitializeImageType()
{
ADD_DEFAULT_IMAGE_TYPES(Dim);
- ADD_VEC_IMAGE_TYPE(Dim, 2, char)
- ADD_VEC_IMAGE_TYPE(Dim, 3, char)
- ADD_VEC_IMAGE_TYPE(Dim, 2, unsigned char)
- ADD_VEC_IMAGE_TYPE(Dim, 3, unsigned char)
- ADD_VEC_IMAGE_TYPE(Dim, 2, short)
- ADD_VEC_IMAGE_TYPE(Dim, 3, short)
- ADD_VEC_IMAGE_TYPE(Dim, 2, unsigned short)
- ADD_VEC_IMAGE_TYPE(Dim, 3, unsigned short)
- ADD_VEC_IMAGE_TYPE(Dim, 2, int)
- ADD_VEC_IMAGE_TYPE(Dim, 3, int)
- ADD_VEC_IMAGE_TYPE(Dim, 2, float)
- ADD_VEC_IMAGE_TYPE(Dim, 3, float)
- ADD_VEC_IMAGE_TYPE(Dim, 2, double)
- ADD_VEC_IMAGE_TYPE(Dim, 3, double)
+ ADD_VEC_IMAGE_TYPE(Dim, 2, float);
+ ADD_VEC_IMAGE_TYPE(Dim, 3, float);
+ ADD_VEC_IMAGE_TYPE(Dim, 2, double);
+ ADD_VEC_IMAGE_TYPE(Dim, 3, double);
}
//--------------------------------------------------------------------
template<class InputImageType>
void clitk::ImageConvertGenericFilter::UpdateWithInputImageType()
{
-
// Verbose stuff
if (m_IOVerbose) {
if (m_InputFilenames.size() == 1) {
}
}
-
if ((m_PixelTypeName == mOutputPixelTypeName) || (mOutputPixelTypeName == "NotSpecified")) {
- // typename InputImageType::Pointer input = clitk::readImage<InputImageType>(m_InputFilenames);
typename InputImageType::Pointer input = this->template GetInput<InputImageType>(0);
- //clitk::writeImage<InputImageType>(input, mOutputFilename, m_IOVerbose);
this->SetNextOutput<InputImageType>(input);
} else {
-#define TRY_TYPE(TYPE) \
- if (IsSameType<TYPE>(mOutputPixelTypeName)) { UpdateWithOutputType<InputImageType, TYPE>(); return; }
- TRY_TYPE(char);
- // TRY_TYPE(signed char);
- TRY_TYPE(uchar);
- TRY_TYPE(short);
- TRY_TYPE(ushort);
- TRY_TYPE(int); // no uint ...
- TRY_TYPE(float);
- TRY_TYPE(double);
-#undef TRY_TYPE
-
- IsSameType<char>("char");
-
- std::string list = CreateListOfTypes<char, uchar, short, ushort, int, float, double>();
- std::cerr << "Error, I don't know the output type '" << mOutputPixelTypeName << " (input = " << m_PixelTypeName << ")"
- << "'. " << std::endl << "Known types are " << list << "." << std::endl;
- exit(0);
- }
-}
-//====================================================================
-
-//====================================================================
-template<class InputImageType, class OutputPixelType>
-void clitk::ImageConvertGenericFilter::UpdateWithOutputType()
-{
- // Read
- typename InputImageType::Pointer input =this->template GetInput<InputImageType>(0);
-
- // Typedef
- typedef typename InputImageType::PixelType PixelType;
-
- // Warning
- std::ostringstream osstream;
- if (std::numeric_limits<PixelType>::is_signed) {
- if (!std::numeric_limits<OutputPixelType>::is_signed) {
- osstream << "Warning, input type is signed (" << m_PixelTypeName << ") while output type is not ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
- }
- }
- if (!std::numeric_limits<PixelType>::is_integer) {
- if (std::numeric_limits<OutputPixelType>::is_integer) {
- osstream << "Warning, input type is not integer (" << m_PixelTypeName << ") while output type is ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
- }
- }
- // DD(std::numeric_limits<PixelType>::digits10);
- // DD(std::numeric_limits<OutputPixelType>::digits10);
- if (!std::numeric_limits<PixelType>::is_integer) {
- if (std::numeric_limits<OutputPixelType>::is_integer) {
- osstream << "Warning, input type is not integer (" << m_PixelTypeName << ") while output type is ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
- }
- }
- if (std::numeric_limits<PixelType>::digits10 > std::numeric_limits<OutputPixelType>::digits10) {
- osstream << "Warning, possible loss of precision : input type is (" << m_PixelTypeName << ") while output type is ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
- }
-
- mWarning = osstream.str();
- if (mDisplayWarning) {
- std::cerr << mWarning;
+ // "trick" to call independent versions of update according to the
+ // pixel type (vector or scalar), using partial specializations
+ if (!UpdateWithSelectiveOutputType<InputImageType, ImageConvertTraits<typename InputImageType::PixelType>::IS_VECTOR>::Run(*this, mOutputPixelTypeName))
+ exit(-1);
}
-
- // Cast
- typedef itk::Image<OutputPixelType,InputImageType::ImageDimension> OutputImageType;
- typedef itk::CastImageFilter<InputImageType, OutputImageType> FilterType;
- typename FilterType::Pointer filter = FilterType::New();
- filter->SetInput(input);
- filter->Update();
-
- // Write
- SetNextOutput<OutputImageType>(filter->GetOutput());
- //clitk::writeImage<OutputImageType>(filter->GetOutput(), mOutputFilename, m_IOVerbose);
}
//====================================================================
-// Vector specializations (RP: do we need so many?)
-
-#define VEC_UPDATE_IMPL(TYPE_IN, COMP, DIM, TYPE_OUT) \
- template<> \
- void clitk::ImageConvertGenericFilter::UpdateWithOutputType<itk::Image<itk::Vector<TYPE_IN, COMP>, DIM>, TYPE_OUT>() \
- { \
- UpdateWithOutputVectorType<itk::Image<itk::Vector<TYPE_IN, COMP>, DIM>, TYPE_OUT>(); \
- }
-
-VEC_UPDATE_IMPL(char, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(char, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(char, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(char, 2, 2, char);
-VEC_UPDATE_IMPL(char, 2, 3, char);
-VEC_UPDATE_IMPL(char, 2, 4, char);
-VEC_UPDATE_IMPL(char, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(char, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(char, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(char, 2, 2, short);
-VEC_UPDATE_IMPL(char, 2, 3, short);
-VEC_UPDATE_IMPL(char, 2, 4, short);
-VEC_UPDATE_IMPL(char, 2, 2, int);
-VEC_UPDATE_IMPL(char, 2, 3, int);
-VEC_UPDATE_IMPL(char, 2, 4, int);
-VEC_UPDATE_IMPL(char, 2, 2, float);
-VEC_UPDATE_IMPL(char, 2, 3, float);
-VEC_UPDATE_IMPL(char, 2, 4, float);
-VEC_UPDATE_IMPL(char, 2, 2, double);
-VEC_UPDATE_IMPL(char, 2, 3, double);
-VEC_UPDATE_IMPL(char, 2, 4, double);
-
-VEC_UPDATE_IMPL(char, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(char, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(char, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(char, 3, 2, char);
-VEC_UPDATE_IMPL(char, 3, 3, char);
-VEC_UPDATE_IMPL(char, 3, 4, char);
-VEC_UPDATE_IMPL(char, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(char, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(char, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(char, 3, 2, short);
-VEC_UPDATE_IMPL(char, 3, 3, short);
-VEC_UPDATE_IMPL(char, 3, 4, short);
-VEC_UPDATE_IMPL(char, 3, 2, int);
-VEC_UPDATE_IMPL(char, 3, 3, int);
-VEC_UPDATE_IMPL(char, 3, 4, int);
-VEC_UPDATE_IMPL(char, 3, 2, float);
-VEC_UPDATE_IMPL(char, 3, 3, float);
-VEC_UPDATE_IMPL(char, 3, 4, float);
-VEC_UPDATE_IMPL(char, 3, 2, double);
-VEC_UPDATE_IMPL(char, 3, 3, double);
-VEC_UPDATE_IMPL(char, 3, 4, double);
-
-VEC_UPDATE_IMPL(unsigned char, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(unsigned char, 2, 2, char);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, char);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, char);
-VEC_UPDATE_IMPL(unsigned char, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(unsigned char, 2, 2, short);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, short);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, short);
-VEC_UPDATE_IMPL(unsigned char, 2, 2, int);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, int);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, int);
-VEC_UPDATE_IMPL(unsigned char, 2, 2, float);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, float);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, float);
-VEC_UPDATE_IMPL(unsigned char, 2, 2, double);
-VEC_UPDATE_IMPL(unsigned char, 2, 3, double);
-VEC_UPDATE_IMPL(unsigned char, 2, 4, double);
-
-VEC_UPDATE_IMPL(unsigned char, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(unsigned char, 3, 2, char);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, char);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, char);
-VEC_UPDATE_IMPL(unsigned char, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(unsigned char, 3, 2, short);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, short);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, short);
-VEC_UPDATE_IMPL(unsigned char, 3, 2, int);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, int);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, int);
-VEC_UPDATE_IMPL(unsigned char, 3, 2, float);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, float);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, float);
-VEC_UPDATE_IMPL(unsigned char, 3, 2, double);
-VEC_UPDATE_IMPL(unsigned char, 3, 3, double);
-VEC_UPDATE_IMPL(unsigned char, 3, 4, double);
-
-VEC_UPDATE_IMPL(short, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(short, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(short, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(short, 2, 2, char);
-VEC_UPDATE_IMPL(short, 2, 3, char);
-VEC_UPDATE_IMPL(short, 2, 4, char);
-VEC_UPDATE_IMPL(short, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(short, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(short, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(short, 2, 2, short);
-VEC_UPDATE_IMPL(short, 2, 3, short);
-VEC_UPDATE_IMPL(short, 2, 4, short);
-VEC_UPDATE_IMPL(short, 2, 2, int);
-VEC_UPDATE_IMPL(short, 2, 3, int);
-VEC_UPDATE_IMPL(short, 2, 4, int);
-VEC_UPDATE_IMPL(short, 2, 2, float);
-VEC_UPDATE_IMPL(short, 2, 3, float);
-VEC_UPDATE_IMPL(short, 2, 4, float);
-VEC_UPDATE_IMPL(short, 2, 2, double);
-VEC_UPDATE_IMPL(short, 2, 3, double);
-VEC_UPDATE_IMPL(short, 2, 4, double);
-
-VEC_UPDATE_IMPL(short, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(short, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(short, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(short, 3, 2, char);
-VEC_UPDATE_IMPL(short, 3, 3, char);
-VEC_UPDATE_IMPL(short, 3, 4, char);
-VEC_UPDATE_IMPL(short, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(short, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(short, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(short, 3, 2, short);
-VEC_UPDATE_IMPL(short, 3, 3, short);
-VEC_UPDATE_IMPL(short, 3, 4, short);
-VEC_UPDATE_IMPL(short, 3, 2, int);
-VEC_UPDATE_IMPL(short, 3, 3, int);
-VEC_UPDATE_IMPL(short, 3, 4, int);
-VEC_UPDATE_IMPL(short, 3, 2, float);
-VEC_UPDATE_IMPL(short, 3, 3, float);
-VEC_UPDATE_IMPL(short, 3, 4, float);
-VEC_UPDATE_IMPL(short, 3, 2, double);
-VEC_UPDATE_IMPL(short, 3, 3, double);
-VEC_UPDATE_IMPL(short, 3, 4, double);
-
-VEC_UPDATE_IMPL(unsigned short, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(unsigned short, 2, 2, char);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, char);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, char);
-VEC_UPDATE_IMPL(unsigned short, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(unsigned short, 2, 2, short);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, short);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, short);
-VEC_UPDATE_IMPL(unsigned short, 2, 2, int);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, int);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, int);
-VEC_UPDATE_IMPL(unsigned short, 2, 2, float);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, float);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, float);
-VEC_UPDATE_IMPL(unsigned short, 2, 2, double);
-VEC_UPDATE_IMPL(unsigned short, 2, 3, double);
-VEC_UPDATE_IMPL(unsigned short, 2, 4, double);
-
-VEC_UPDATE_IMPL(unsigned short, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(unsigned short, 3, 2, char);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, char);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, char);
-VEC_UPDATE_IMPL(unsigned short, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(unsigned short, 3, 2, short);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, short);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, short);
-VEC_UPDATE_IMPL(unsigned short, 3, 2, int);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, int);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, int);
-VEC_UPDATE_IMPL(unsigned short, 3, 2, float);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, float);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, float);
-VEC_UPDATE_IMPL(unsigned short, 3, 2, double);
-VEC_UPDATE_IMPL(unsigned short, 3, 3, double);
-VEC_UPDATE_IMPL(unsigned short, 3, 4, double);
-
-VEC_UPDATE_IMPL(int, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(int, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(int, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(int, 2, 2, char);
-VEC_UPDATE_IMPL(int, 2, 3, char);
-VEC_UPDATE_IMPL(int, 2, 4, char);
-VEC_UPDATE_IMPL(int, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(int, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(int, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(int, 2, 2, short);
-VEC_UPDATE_IMPL(int, 2, 3, short);
-VEC_UPDATE_IMPL(int, 2, 4, short);
-VEC_UPDATE_IMPL(int, 2, 2, int);
-VEC_UPDATE_IMPL(int, 2, 3, int);
-VEC_UPDATE_IMPL(int, 2, 4, int);
-VEC_UPDATE_IMPL(int, 2, 2, float);
-VEC_UPDATE_IMPL(int, 2, 3, float);
-VEC_UPDATE_IMPL(int, 2, 4, float);
-VEC_UPDATE_IMPL(int, 2, 2, double);
-VEC_UPDATE_IMPL(int, 2, 3, double);
-VEC_UPDATE_IMPL(int, 2, 4, double);
-
-VEC_UPDATE_IMPL(int, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(int, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(int, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(int, 3, 2, char);
-VEC_UPDATE_IMPL(int, 3, 3, char);
-VEC_UPDATE_IMPL(int, 3, 4, char);
-VEC_UPDATE_IMPL(int, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(int, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(int, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(int, 3, 2, short);
-VEC_UPDATE_IMPL(int, 3, 3, short);
-VEC_UPDATE_IMPL(int, 3, 4, short);
-VEC_UPDATE_IMPL(int, 3, 2, int);
-VEC_UPDATE_IMPL(int, 3, 3, int);
-VEC_UPDATE_IMPL(int, 3, 4, int);
-VEC_UPDATE_IMPL(int, 3, 2, float);
-VEC_UPDATE_IMPL(int, 3, 3, float);
-VEC_UPDATE_IMPL(int, 3, 4, float);
-VEC_UPDATE_IMPL(int, 3, 2, double);
-VEC_UPDATE_IMPL(int, 3, 3, double);
-VEC_UPDATE_IMPL(int, 3, 4, double);
-
-VEC_UPDATE_IMPL(float, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(float, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(float, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(float, 2, 2, char);
-VEC_UPDATE_IMPL(float, 2, 3, char);
-VEC_UPDATE_IMPL(float, 2, 4, char);
-VEC_UPDATE_IMPL(float, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(float, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(float, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(float, 2, 2, short);
-VEC_UPDATE_IMPL(float, 2, 3, short);
-VEC_UPDATE_IMPL(float, 2, 4, short);
-VEC_UPDATE_IMPL(float, 2, 2, int);
-VEC_UPDATE_IMPL(float, 2, 3, int);
-VEC_UPDATE_IMPL(float, 2, 4, int);
-VEC_UPDATE_IMPL(float, 2, 2, float);
-VEC_UPDATE_IMPL(float, 2, 3, float);
-VEC_UPDATE_IMPL(float, 2, 4, float);
-VEC_UPDATE_IMPL(float, 2, 2, double);
-VEC_UPDATE_IMPL(float, 2, 3, double);
-VEC_UPDATE_IMPL(float, 2, 4, double);
-
-VEC_UPDATE_IMPL(float, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(float, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(float, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(float, 3, 2, char);
-VEC_UPDATE_IMPL(float, 3, 3, char);
-VEC_UPDATE_IMPL(float, 3, 4, char);
-VEC_UPDATE_IMPL(float, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(float, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(float, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(float, 3, 2, short);
-VEC_UPDATE_IMPL(float, 3, 3, short);
-VEC_UPDATE_IMPL(float, 3, 4, short);
-VEC_UPDATE_IMPL(float, 3, 2, int);
-VEC_UPDATE_IMPL(float, 3, 3, int);
-VEC_UPDATE_IMPL(float, 3, 4, int);
-VEC_UPDATE_IMPL(float, 3, 2, float);
-VEC_UPDATE_IMPL(float, 3, 3, float);
-VEC_UPDATE_IMPL(float, 3, 4, float);
-VEC_UPDATE_IMPL(float, 3, 2, double);
-VEC_UPDATE_IMPL(float, 3, 3, double);
-VEC_UPDATE_IMPL(float, 3, 4, double);
-
-
-VEC_UPDATE_IMPL(double, 2, 2, unsigned char);
-VEC_UPDATE_IMPL(double, 2, 3, unsigned char);
-VEC_UPDATE_IMPL(double, 2, 4, unsigned char);
-VEC_UPDATE_IMPL(double, 2, 2, char);
-VEC_UPDATE_IMPL(double, 2, 3, char);
-VEC_UPDATE_IMPL(double, 2, 4, char);
-VEC_UPDATE_IMPL(double, 2, 2, unsigned short);
-VEC_UPDATE_IMPL(double, 2, 3, unsigned short);
-VEC_UPDATE_IMPL(double, 2, 4, unsigned short);
-VEC_UPDATE_IMPL(double, 2, 2, short);
-VEC_UPDATE_IMPL(double, 2, 3, short);
-VEC_UPDATE_IMPL(double, 2, 4, short);
-VEC_UPDATE_IMPL(double, 2, 2, int);
-VEC_UPDATE_IMPL(double, 2, 3, int);
-VEC_UPDATE_IMPL(double, 2, 4, int);
-VEC_UPDATE_IMPL(double, 2, 2, float);
-VEC_UPDATE_IMPL(double, 2, 3, float);
-VEC_UPDATE_IMPL(double, 2, 4, float);
-VEC_UPDATE_IMPL(double, 2, 2, double);
-VEC_UPDATE_IMPL(double, 2, 3, double);
-VEC_UPDATE_IMPL(double, 2, 4, double);
-
-VEC_UPDATE_IMPL(double, 3, 2, unsigned char);
-VEC_UPDATE_IMPL(double, 3, 3, unsigned char);
-VEC_UPDATE_IMPL(double, 3, 4, unsigned char);
-VEC_UPDATE_IMPL(double, 3, 2, char);
-VEC_UPDATE_IMPL(double, 3, 3, char);
-VEC_UPDATE_IMPL(double, 3, 4, char);
-VEC_UPDATE_IMPL(double, 3, 2, unsigned short);
-VEC_UPDATE_IMPL(double, 3, 3, unsigned short);
-VEC_UPDATE_IMPL(double, 3, 4, unsigned short);
-VEC_UPDATE_IMPL(double, 3, 2, short);
-VEC_UPDATE_IMPL(double, 3, 3, short);
-VEC_UPDATE_IMPL(double, 3, 4, short);
-VEC_UPDATE_IMPL(double, 3, 2, int);
-VEC_UPDATE_IMPL(double, 3, 3, int);
-VEC_UPDATE_IMPL(double, 3, 4, int);
-VEC_UPDATE_IMPL(double, 3, 2, float);
-VEC_UPDATE_IMPL(double, 3, 3, float);
-VEC_UPDATE_IMPL(double, 3, 4, float);
-VEC_UPDATE_IMPL(double, 3, 2, double);
-VEC_UPDATE_IMPL(double, 3, 3, double);
-VEC_UPDATE_IMPL(double, 3, 4, double);
//====================================================================
-//====================================================================
-template<class InputImageType, class OutputPixelType>
-void clitk::ImageConvertGenericFilter::UpdateWithOutputVectorType()
+template<class PixelType, class OutputPixelType>
+void clitk::ImageConvertGenericFilter::CheckTypes(
+ std::string inType, std::string outType
+)
{
- // Read
- typename InputImageType::Pointer input =this->template GetInput<InputImageType>(0);
-
- // Typedef
- typedef typename InputImageType::PixelType::ValueType PixelType;
-
- // Warning
std::ostringstream osstream;
if (std::numeric_limits<PixelType>::is_signed) {
if (!std::numeric_limits<OutputPixelType>::is_signed) {
- osstream << "Warning, input type is signed (" << m_PixelTypeName << ") while output type is not ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
+ osstream << "Warning, input type is signed (";
}
}
if (!std::numeric_limits<PixelType>::is_integer) {
if (std::numeric_limits<OutputPixelType>::is_integer) {
- osstream << "Warning, input type is not integer (" << m_PixelTypeName << ") while output type is ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
+ osstream << "Warning, input type is not integer (";
}
}
// DD(std::numeric_limits<PixelType>::digits10);
// DD(std::numeric_limits<OutputPixelType>::digits10);
if (!std::numeric_limits<PixelType>::is_integer) {
if (std::numeric_limits<OutputPixelType>::is_integer) {
- osstream << "Warning, input type is not integer (" << m_PixelTypeName << ") while output type is ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
+ osstream << "Warning, input type is not integer (";
}
}
if (std::numeric_limits<PixelType>::digits10 > std::numeric_limits<OutputPixelType>::digits10) {
- osstream << "Warning, possible loss of precision : input type is (" << m_PixelTypeName << ") while output type is ("
- << mOutputPixelTypeName << "), use at your own responsability." << std::endl;
- mWarningOccur = true;
+ osstream << "Warning, possible loss of precision : input type is (" ;
}
- mWarning = osstream.str();
- if (mDisplayWarning) {
- std::cerr << mWarning;
+ if (!osstream.str().empty())
+ {
+ mWarningOccur = true;
+ osstream << inType << ") while output type is (" << outType << "), use at your own responsability." << std::endl;
+ mWarning = osstream.str();
+ if (mDisplayWarning) {
+ std::cerr << mWarning;
+ }
}
-
- // Cast
- typedef itk::Image<itk::Vector<OutputPixelType, InputImageType::PixelType::Dimension>, InputImageType::ImageDimension> OutputImageType;
- typedef itk::VectorCastImageFilter<InputImageType, OutputImageType> FilterType;
- typename FilterType::Pointer filter = FilterType::New();
- filter->SetInput(input);
- filter->Update();
-
- // Write
- SetNextOutput<OutputImageType>(filter->GetOutput());
- //clitk::writeImage<OutputImageType>(filter->GetOutput(), mOutputFilename, m_IOVerbose);
}
-//====================================================================
+
#endif /* end #define CLITKIMAGECONVERTGENERICFILTER_CXX */
// clitk include
#include "clitkImageToImageGenericFilter.h"
+// itk include
+#include "itkCastImageFilter.h"
+#include "itkVectorCastImageFilter.h"
+
namespace clitk {
+ template <class TPixel>
+ class ImageConvertTraits
+ {
+ public:
+ enum { IS_VECTOR = false };
+ ImageConvertTraits() {
+ TPixel p = "SCALAR";
+ }
+ };
+
+ template < class TPixel, unsigned int Comp >
+ class ImageConvertTraits< itk::Vector<TPixel, Comp> >
+ {
+ public:
+ enum { IS_VECTOR = true };
+ };
+
class ImageConvertGenericFilter:
public clitk::ImageToImageGenericFilter<ImageConvertGenericFilter> {
itkNewMacro(Self);
// Members functions
+ std::string GetInputPixelTypeName() { return m_PixelTypeName; }
+ std::string GetOutputPixelTypeName() { return mOutputPixelTypeName; }
void SetOutputPixelType(std::string p) { mOutputPixelTypeName = p; }
bool IsWarningOccur() { return mWarningOccur; }
std::string & GetWarning() { return mWarning; }
template<class InputImageType>
void UpdateWithInputImageType();
+ template<class PixelType, class OutputPixelType>
+ void CheckTypes(std::string inType, std::string outType);
+
protected:
+
template<unsigned int Dim> void InitializeImageType();
std::string mOutputPixelTypeName;
std::string mWarning;
bool mWarningOccur;
bool mDisplayWarning;
- template<class InputImageType, class OutputPixelType> void UpdateWithOutputType();
- template<class InputImageType, class OutputPixelType> void UpdateWithOutputVectorType();
-
+ private:
+ template <class InputImageType, bool isVector>
+ class UpdateWithSelectiveOutputType
+ {
+ public:
+ static bool Run(ImageConvertGenericFilter& filter, std::string outputPixelType)
+ {
+ if (IsSameType<char>(outputPixelType))
+ UpdateWithOutputType<char>(filter);
+ else if (IsSameType<uchar>(outputPixelType))
+ UpdateWithOutputType<uchar>(filter);
+ else if (IsSameType<short>(outputPixelType))
+ UpdateWithOutputType<short>(filter);
+ else if (IsSameType<ushort>(outputPixelType))
+ UpdateWithOutputType<ushort>(filter);
+ else if (IsSameType<int>(outputPixelType))
+ UpdateWithOutputType<int>(filter);
+ else if (IsSameType<float>(outputPixelType))
+ UpdateWithOutputType<float>(filter);
+ else if (IsSameType<double>(outputPixelType))
+ UpdateWithOutputType<double>(filter);
+ else
+ {
+ std::string list = CreateListOfTypes<float, double>();
+ std::cerr << "Error, I don't know the vector output type '" << outputPixelType
+ << "'. " << std::endl << "Known types are " << list << "." << std::endl;
+ return false;
+ }
+
+ return true;
+ }
+
+ private:
+
+ template <class OutputPixelType>
+ static void UpdateWithOutputType(ImageConvertGenericFilter& filter)
+ {
+ // Read
+ typename InputImageType::Pointer input =filter.template GetInput<InputImageType>(0);
+
+ // Typedef
+ typedef typename InputImageType::PixelType PixelType;
+
+ // Warning
+ filter.CheckTypes<PixelType, OutputPixelType>(filter.GetInputPixelTypeName(), filter.GetOutputPixelTypeName());
+
+ // Cast
+ typedef itk::Image<OutputPixelType,InputImageType::ImageDimension> OutputImageType;
+ typedef itk::CastImageFilter<InputImageType, OutputImageType> FilterType;
+ typename FilterType::Pointer cast_filter = FilterType::New();
+ cast_filter->SetInput(input);
+ cast_filter->Update();
+
+ // Write
+ filter.SetNextOutput<OutputImageType>(cast_filter->GetOutput());
+ }
+ };
+
+ template <class InputImageType>
+ class UpdateWithSelectiveOutputType<InputImageType, true>
+ {
+ public:
+ static bool Run(ImageConvertGenericFilter& filter, std::string outputPixelType)
+ {
+ /*
+ // RP: future conversions?
+ if (IsSameType<char>(outputPixelType))
+ UpdateWithOutputVectorType<char>();
+ else if (IsSameType<uchar>(outputPixelType))
+ UpdateWithOutputVectorType<uchar>();
+ else if (IsSameType<short>(outputPixelType))
+ UpdateWithOutputVectorType<short>();
+ else if (IsSameType<ushort>(outputPixelType))
+ UpdateWithOutputVectorType<ushort>();
+ else if (IsSameType<int>(outputPixelType))
+ UpdateWithOutputVectorType<int>();
+ else
+ */
+ if (IsSameType<float>(outputPixelType))
+ UpdateWithOutputVectorType<float>(filter);
+ else if (IsSameType<double>(outputPixelType))
+ UpdateWithOutputVectorType<double>(filter);
+ else
+ {
+ std::string list = CreateListOfTypes<float, double>();
+ std::cerr << "Error, I don't know the vector output type '" << outputPixelType
+ << "'. " << std::endl << "Known types are " << list << "." << std::endl;
+ return false;
+ }
+
+ return true;
+ }
+
+ private:
+
+ template <class OutputPixelType>
+ static void UpdateWithOutputVectorType(ImageConvertGenericFilter& filter)
+ {
+ // Read
+ typename InputImageType::Pointer input =filter.template GetInput<InputImageType>(0);
+
+ // Typedef
+ typedef typename InputImageType::PixelType::ValueType PixelType;
+
+ // Warning
+ filter.CheckTypes<PixelType, OutputPixelType>(filter.GetInputPixelTypeName(), filter.GetOutputPixelTypeName());
+
+ // Cast
+ typedef itk::Image<itk::Vector<OutputPixelType, InputImageType::PixelType::Dimension>, InputImageType::ImageDimension> OutputImageType;
+ typedef itk::VectorCastImageFilter<InputImageType, OutputImageType> FilterType;
+ typename FilterType::Pointer cast_filter = FilterType::New();
+ cast_filter->SetInput(input);
+ cast_filter->Update();
+
+ // Write
+ filter.SetNextOutput<OutputImageType>(cast_filter->GetOutput());
+ }
+ };
}; // end class ImageConvertGenericFilter
-#define VEC_UPDATE_DECL(TYPE_IN, COMP, DIM, TYPE_OUT) \
- template<> void ImageConvertGenericFilter::UpdateWithOutputType<itk::Image<itk::Vector<TYPE_IN, COMP>, DIM>, TYPE_OUT>()
-
-VEC_UPDATE_DECL(char, 2, 2, unsigned char);
-VEC_UPDATE_DECL(char, 2, 3, unsigned char);
-VEC_UPDATE_DECL(char, 2, 4, unsigned char);
-VEC_UPDATE_DECL(char, 2, 2, char);
-VEC_UPDATE_DECL(char, 2, 3, char);
-VEC_UPDATE_DECL(char, 2, 4, char);
-VEC_UPDATE_DECL(char, 2, 2, unsigned short);
-VEC_UPDATE_DECL(char, 2, 3, unsigned short);
-VEC_UPDATE_DECL(char, 2, 4, unsigned short);
-VEC_UPDATE_DECL(char, 2, 2, short);
-VEC_UPDATE_DECL(char, 2, 3, short);
-VEC_UPDATE_DECL(char, 2, 4, short);
-VEC_UPDATE_DECL(char, 2, 2, int);
-VEC_UPDATE_DECL(char, 2, 3, int);
-VEC_UPDATE_DECL(char, 2, 4, int);
-VEC_UPDATE_DECL(char, 2, 2, float);
-VEC_UPDATE_DECL(char, 2, 3, float);
-VEC_UPDATE_DECL(char, 2, 4, float);
-VEC_UPDATE_DECL(char, 2, 2, double);
-VEC_UPDATE_DECL(char, 2, 3, double);
-VEC_UPDATE_DECL(char, 2, 4, double);
-
-VEC_UPDATE_DECL(char, 3, 2, unsigned char);
-VEC_UPDATE_DECL(char, 3, 3, unsigned char);
-VEC_UPDATE_DECL(char, 3, 4, unsigned char);
-VEC_UPDATE_DECL(char, 3, 2, char);
-VEC_UPDATE_DECL(char, 3, 3, char);
-VEC_UPDATE_DECL(char, 3, 4, char);
-VEC_UPDATE_DECL(char, 3, 2, unsigned short);
-VEC_UPDATE_DECL(char, 3, 3, unsigned short);
-VEC_UPDATE_DECL(char, 3, 4, unsigned short);
-VEC_UPDATE_DECL(char, 3, 2, short);
-VEC_UPDATE_DECL(char, 3, 3, short);
-VEC_UPDATE_DECL(char, 3, 4, short);
-VEC_UPDATE_DECL(char, 3, 2, int);
-VEC_UPDATE_DECL(char, 3, 3, int);
-VEC_UPDATE_DECL(char, 3, 4, int);
-VEC_UPDATE_DECL(char, 3, 2, float);
-VEC_UPDATE_DECL(char, 3, 3, float);
-VEC_UPDATE_DECL(char, 3, 4, float);
-VEC_UPDATE_DECL(char, 3, 2, double);
-VEC_UPDATE_DECL(char, 3, 3, double);
-VEC_UPDATE_DECL(char, 3, 4, double);
-
-VEC_UPDATE_DECL(unsigned char, 2, 2, unsigned char);
-VEC_UPDATE_DECL(unsigned char, 2, 3, unsigned char);
-VEC_UPDATE_DECL(unsigned char, 2, 4, unsigned char);
-VEC_UPDATE_DECL(unsigned char, 2, 2, char);
-VEC_UPDATE_DECL(unsigned char, 2, 3, char);
-VEC_UPDATE_DECL(unsigned char, 2, 4, char);
-VEC_UPDATE_DECL(unsigned char, 2, 2, unsigned short);
-VEC_UPDATE_DECL(unsigned char, 2, 3, unsigned short);
-VEC_UPDATE_DECL(unsigned char, 2, 4, unsigned short);
-VEC_UPDATE_DECL(unsigned char, 2, 2, short);
-VEC_UPDATE_DECL(unsigned char, 2, 3, short);
-VEC_UPDATE_DECL(unsigned char, 2, 4, short);
-VEC_UPDATE_DECL(unsigned char, 2, 2, int);
-VEC_UPDATE_DECL(unsigned char, 2, 3, int);
-VEC_UPDATE_DECL(unsigned char, 2, 4, int);
-VEC_UPDATE_DECL(unsigned char, 2, 2, float);
-VEC_UPDATE_DECL(unsigned char, 2, 3, float);
-VEC_UPDATE_DECL(unsigned char, 2, 4, float);
-VEC_UPDATE_DECL(unsigned char, 2, 2, double);
-VEC_UPDATE_DECL(unsigned char, 2, 3, double);
-VEC_UPDATE_DECL(unsigned char, 2, 4, double);
-
-VEC_UPDATE_DECL(unsigned char, 3, 2, unsigned char);
-VEC_UPDATE_DECL(unsigned char, 3, 3, unsigned char);
-VEC_UPDATE_DECL(unsigned char, 3, 4, unsigned char);
-VEC_UPDATE_DECL(unsigned char, 3, 2, char);
-VEC_UPDATE_DECL(unsigned char, 3, 3, char);
-VEC_UPDATE_DECL(unsigned char, 3, 4, char);
-VEC_UPDATE_DECL(unsigned char, 3, 2, unsigned short);
-VEC_UPDATE_DECL(unsigned char, 3, 3, unsigned short);
-VEC_UPDATE_DECL(unsigned char, 3, 4, unsigned short);
-VEC_UPDATE_DECL(unsigned char, 3, 2, short);
-VEC_UPDATE_DECL(unsigned char, 3, 3, short);
-VEC_UPDATE_DECL(unsigned char, 3, 4, short);
-VEC_UPDATE_DECL(unsigned char, 3, 2, int);
-VEC_UPDATE_DECL(unsigned char, 3, 3, int);
-VEC_UPDATE_DECL(unsigned char, 3, 4, int);
-VEC_UPDATE_DECL(unsigned char, 3, 2, float);
-VEC_UPDATE_DECL(unsigned char, 3, 3, float);
-VEC_UPDATE_DECL(unsigned char, 3, 4, float);
-VEC_UPDATE_DECL(unsigned char, 3, 2, double);
-VEC_UPDATE_DECL(unsigned char, 3, 3, double);
-VEC_UPDATE_DECL(unsigned char, 3, 4, double);
-
-VEC_UPDATE_DECL(short, 2, 2, unsigned char);
-VEC_UPDATE_DECL(short, 2, 3, unsigned char);
-VEC_UPDATE_DECL(short, 2, 4, unsigned char);
-VEC_UPDATE_DECL(short, 2, 2, char);
-VEC_UPDATE_DECL(short, 2, 3, char);
-VEC_UPDATE_DECL(short, 2, 4, char);
-VEC_UPDATE_DECL(short, 2, 2, unsigned short);
-VEC_UPDATE_DECL(short, 2, 3, unsigned short);
-VEC_UPDATE_DECL(short, 2, 4, unsigned short);
-VEC_UPDATE_DECL(short, 2, 2, short);
-VEC_UPDATE_DECL(short, 2, 3, short);
-VEC_UPDATE_DECL(short, 2, 4, short);
-VEC_UPDATE_DECL(short, 2, 2, int);
-VEC_UPDATE_DECL(short, 2, 3, int);
-VEC_UPDATE_DECL(short, 2, 4, int);
-VEC_UPDATE_DECL(short, 2, 2, float);
-VEC_UPDATE_DECL(short, 2, 3, float);
-VEC_UPDATE_DECL(short, 2, 4, float);
-VEC_UPDATE_DECL(short, 2, 2, double);
-VEC_UPDATE_DECL(short, 2, 3, double);
-VEC_UPDATE_DECL(short, 2, 4, double);
-
-VEC_UPDATE_DECL(short, 3, 2, unsigned char);
-VEC_UPDATE_DECL(short, 3, 3, unsigned char);
-VEC_UPDATE_DECL(short, 3, 4, unsigned char);
-VEC_UPDATE_DECL(short, 3, 2, char);
-VEC_UPDATE_DECL(short, 3, 3, char);
-VEC_UPDATE_DECL(short, 3, 4, char);
-VEC_UPDATE_DECL(short, 3, 2, unsigned short);
-VEC_UPDATE_DECL(short, 3, 3, unsigned short);
-VEC_UPDATE_DECL(short, 3, 4, unsigned short);
-VEC_UPDATE_DECL(short, 3, 2, short);
-VEC_UPDATE_DECL(short, 3, 3, short);
-VEC_UPDATE_DECL(short, 3, 4, short);
-VEC_UPDATE_DECL(short, 3, 2, int);
-VEC_UPDATE_DECL(short, 3, 3, int);
-VEC_UPDATE_DECL(short, 3, 4, int);
-VEC_UPDATE_DECL(short, 3, 2, float);
-VEC_UPDATE_DECL(short, 3, 3, float);
-VEC_UPDATE_DECL(short, 3, 4, float);
-VEC_UPDATE_DECL(short, 3, 2, double);
-VEC_UPDATE_DECL(short, 3, 3, double);
-VEC_UPDATE_DECL(short, 3, 4, double);
-
-VEC_UPDATE_DECL(unsigned short, 2, 2, unsigned char);
-VEC_UPDATE_DECL(unsigned short, 2, 3, unsigned char);
-VEC_UPDATE_DECL(unsigned short, 2, 4, unsigned char);
-VEC_UPDATE_DECL(unsigned short, 2, 2, char);
-VEC_UPDATE_DECL(unsigned short, 2, 3, char);
-VEC_UPDATE_DECL(unsigned short, 2, 4, char);
-VEC_UPDATE_DECL(unsigned short, 2, 2, unsigned short);
-VEC_UPDATE_DECL(unsigned short, 2, 3, unsigned short);
-VEC_UPDATE_DECL(unsigned short, 2, 4, unsigned short);
-VEC_UPDATE_DECL(unsigned short, 2, 2, short);
-VEC_UPDATE_DECL(unsigned short, 2, 3, short);
-VEC_UPDATE_DECL(unsigned short, 2, 4, short);
-VEC_UPDATE_DECL(unsigned short, 2, 2, int);
-VEC_UPDATE_DECL(unsigned short, 2, 3, int);
-VEC_UPDATE_DECL(unsigned short, 2, 4, int);
-VEC_UPDATE_DECL(unsigned short, 2, 2, float);
-VEC_UPDATE_DECL(unsigned short, 2, 3, float);
-VEC_UPDATE_DECL(unsigned short, 2, 4, float);
-VEC_UPDATE_DECL(unsigned short, 2, 2, double);
-VEC_UPDATE_DECL(unsigned short, 2, 3, double);
-VEC_UPDATE_DECL(unsigned short, 2, 4, double);
-
-VEC_UPDATE_DECL(unsigned short, 3, 2, unsigned char);
-VEC_UPDATE_DECL(unsigned short, 3, 3, unsigned char);
-VEC_UPDATE_DECL(unsigned short, 3, 4, unsigned char);
-VEC_UPDATE_DECL(unsigned short, 3, 2, char);
-VEC_UPDATE_DECL(unsigned short, 3, 3, char);
-VEC_UPDATE_DECL(unsigned short, 3, 4, char);
-VEC_UPDATE_DECL(unsigned short, 3, 2, unsigned short);
-VEC_UPDATE_DECL(unsigned short, 3, 3, unsigned short);
-VEC_UPDATE_DECL(unsigned short, 3, 4, unsigned short);
-VEC_UPDATE_DECL(unsigned short, 3, 2, short);
-VEC_UPDATE_DECL(unsigned short, 3, 3, short);
-VEC_UPDATE_DECL(unsigned short, 3, 4, short);
-VEC_UPDATE_DECL(unsigned short, 3, 2, int);
-VEC_UPDATE_DECL(unsigned short, 3, 3, int);
-VEC_UPDATE_DECL(unsigned short, 3, 4, int);
-VEC_UPDATE_DECL(unsigned short, 3, 2, float);
-VEC_UPDATE_DECL(unsigned short, 3, 3, float);
-VEC_UPDATE_DECL(unsigned short, 3, 4, float);
-VEC_UPDATE_DECL(unsigned short, 3, 2, double);
-VEC_UPDATE_DECL(unsigned short, 3, 3, double);
-VEC_UPDATE_DECL(unsigned short, 3, 4, double);
-
-VEC_UPDATE_DECL(int, 2, 2, unsigned char);
-VEC_UPDATE_DECL(int, 2, 3, unsigned char);
-VEC_UPDATE_DECL(int, 2, 4, unsigned char);
-VEC_UPDATE_DECL(int, 2, 2, char);
-VEC_UPDATE_DECL(int, 2, 3, char);
-VEC_UPDATE_DECL(int, 2, 4, char);
-VEC_UPDATE_DECL(int, 2, 2, unsigned short);
-VEC_UPDATE_DECL(int, 2, 3, unsigned short);
-VEC_UPDATE_DECL(int, 2, 4, unsigned short);
-VEC_UPDATE_DECL(int, 2, 2, short);
-VEC_UPDATE_DECL(int, 2, 3, short);
-VEC_UPDATE_DECL(int, 2, 4, short);
-VEC_UPDATE_DECL(int, 2, 2, int);
-VEC_UPDATE_DECL(int, 2, 3, int);
-VEC_UPDATE_DECL(int, 2, 4, int);
-VEC_UPDATE_DECL(int, 2, 2, float);
-VEC_UPDATE_DECL(int, 2, 3, float);
-VEC_UPDATE_DECL(int, 2, 4, float);
-VEC_UPDATE_DECL(int, 2, 2, double);
-VEC_UPDATE_DECL(int, 2, 3, double);
-VEC_UPDATE_DECL(int, 2, 4, double);
-
-VEC_UPDATE_DECL(int, 3, 2, unsigned char);
-VEC_UPDATE_DECL(int, 3, 3, unsigned char);
-VEC_UPDATE_DECL(int, 3, 4, unsigned char);
-VEC_UPDATE_DECL(int, 3, 2, char);
-VEC_UPDATE_DECL(int, 3, 3, char);
-VEC_UPDATE_DECL(int, 3, 4, char);
-VEC_UPDATE_DECL(int, 3, 2, unsigned short);
-VEC_UPDATE_DECL(int, 3, 3, unsigned short);
-VEC_UPDATE_DECL(int, 3, 4, unsigned short);
-VEC_UPDATE_DECL(int, 3, 2, short);
-VEC_UPDATE_DECL(int, 3, 3, short);
-VEC_UPDATE_DECL(int, 3, 4, short);
-VEC_UPDATE_DECL(int, 3, 2, int);
-VEC_UPDATE_DECL(int, 3, 3, int);
-VEC_UPDATE_DECL(int, 3, 4, int);
-VEC_UPDATE_DECL(int, 3, 2, float);
-VEC_UPDATE_DECL(int, 3, 3, float);
-VEC_UPDATE_DECL(int, 3, 4, float);
-VEC_UPDATE_DECL(int, 3, 2, double);
-VEC_UPDATE_DECL(int, 3, 3, double);
-VEC_UPDATE_DECL(int, 3, 4, double);
-
-VEC_UPDATE_DECL(float, 2, 2, unsigned char);
-VEC_UPDATE_DECL(float, 2, 3, unsigned char);
-VEC_UPDATE_DECL(float, 2, 4, unsigned char);
-VEC_UPDATE_DECL(float, 2, 2, char);
-VEC_UPDATE_DECL(float, 2, 3, char);
-VEC_UPDATE_DECL(float, 2, 4, char);
-VEC_UPDATE_DECL(float, 2, 2, unsigned short);
-VEC_UPDATE_DECL(float, 2, 3, unsigned short);
-VEC_UPDATE_DECL(float, 2, 4, unsigned short);
-VEC_UPDATE_DECL(float, 2, 2, short);
-VEC_UPDATE_DECL(float, 2, 3, short);
-VEC_UPDATE_DECL(float, 2, 4, short);
-VEC_UPDATE_DECL(float, 2, 2, int);
-VEC_UPDATE_DECL(float, 2, 3, int);
-VEC_UPDATE_DECL(float, 2, 4, int);
-VEC_UPDATE_DECL(float, 2, 2, float);
-VEC_UPDATE_DECL(float, 2, 3, float);
-VEC_UPDATE_DECL(float, 2, 4, float);
-VEC_UPDATE_DECL(float, 2, 2, double);
-VEC_UPDATE_DECL(float, 2, 3, double);
-VEC_UPDATE_DECL(float, 2, 4, double);
-
-VEC_UPDATE_DECL(float, 3, 2, unsigned char);
-VEC_UPDATE_DECL(float, 3, 3, unsigned char);
-VEC_UPDATE_DECL(float, 3, 4, unsigned char);
-VEC_UPDATE_DECL(float, 3, 2, char);
-VEC_UPDATE_DECL(float, 3, 3, char);
-VEC_UPDATE_DECL(float, 3, 4, char);
-VEC_UPDATE_DECL(float, 3, 2, unsigned short);
-VEC_UPDATE_DECL(float, 3, 3, unsigned short);
-VEC_UPDATE_DECL(float, 3, 4, unsigned short);
-VEC_UPDATE_DECL(float, 3, 2, short);
-VEC_UPDATE_DECL(float, 3, 3, short);
-VEC_UPDATE_DECL(float, 3, 4, short);
-VEC_UPDATE_DECL(float, 3, 2, int);
-VEC_UPDATE_DECL(float, 3, 3, int);
-VEC_UPDATE_DECL(float, 3, 4, int);
-VEC_UPDATE_DECL(float, 3, 2, float);
-VEC_UPDATE_DECL(float, 3, 3, float);
-VEC_UPDATE_DECL(float, 3, 4, float);
-VEC_UPDATE_DECL(float, 3, 2, double);
-VEC_UPDATE_DECL(float, 3, 3, double);
-VEC_UPDATE_DECL(float, 3, 4, double);
-
-VEC_UPDATE_DECL(double, 2, 2, unsigned char);
-VEC_UPDATE_DECL(double, 2, 3, unsigned char);
-VEC_UPDATE_DECL(double, 2, 4, unsigned char);
-VEC_UPDATE_DECL(double, 2, 2, char);
-VEC_UPDATE_DECL(double, 2, 3, char);
-VEC_UPDATE_DECL(double, 2, 4, char);
-VEC_UPDATE_DECL(double, 2, 2, unsigned short);
-VEC_UPDATE_DECL(double, 2, 3, unsigned short);
-VEC_UPDATE_DECL(double, 2, 4, unsigned short);
-VEC_UPDATE_DECL(double, 2, 2, short);
-VEC_UPDATE_DECL(double, 2, 3, short);
-VEC_UPDATE_DECL(double, 2, 4, short);
-VEC_UPDATE_DECL(double, 2, 2, int);
-VEC_UPDATE_DECL(double, 2, 3, int);
-VEC_UPDATE_DECL(double, 2, 4, int);
-VEC_UPDATE_DECL(double, 2, 2, float);
-VEC_UPDATE_DECL(double, 2, 3, float);
-VEC_UPDATE_DECL(double, 2, 4, float);
-VEC_UPDATE_DECL(double, 2, 2, double);
-VEC_UPDATE_DECL(double, 2, 3, double);
-VEC_UPDATE_DECL(double, 2, 4, double);
-
-VEC_UPDATE_DECL(double, 3, 2, unsigned char);
-VEC_UPDATE_DECL(double, 3, 3, unsigned char);
-VEC_UPDATE_DECL(double, 3, 4, unsigned char);
-VEC_UPDATE_DECL(double, 3, 2, char);
-VEC_UPDATE_DECL(double, 3, 3, char);
-VEC_UPDATE_DECL(double, 3, 4, char);
-VEC_UPDATE_DECL(double, 3, 2, unsigned short);
-VEC_UPDATE_DECL(double, 3, 3, unsigned short);
-VEC_UPDATE_DECL(double, 3, 4, unsigned short);
-VEC_UPDATE_DECL(double, 3, 2, short);
-VEC_UPDATE_DECL(double, 3, 3, short);
-VEC_UPDATE_DECL(double, 3, 4, short);
-VEC_UPDATE_DECL(double, 3, 2, int);
-VEC_UPDATE_DECL(double, 3, 3, int);
-VEC_UPDATE_DECL(double, 3, 4, int);
-VEC_UPDATE_DECL(double, 3, 2, float);
-VEC_UPDATE_DECL(double, 3, 3, float);
-VEC_UPDATE_DECL(double, 3, 4, float);
-VEC_UPDATE_DECL(double, 3, 2, double);
-VEC_UPDATE_DECL(double, 3, 3, double);
-VEC_UPDATE_DECL(double, 3, 4, double);
-
//#include "clitkImageConvertGenericFilter.txx"
} // end namespace
git://git.creatis.insa-lyon.fr / clitk.git / commitdiff