lib/cpPlugins/Interface/ProcessObject.h

   1 #ifndef __CPPLUGINS__INTERFACE__PROCESSOBJECT__H__
   2 #define __CPPLUGINS__INTERFACE__PROCESSOBJECT__H__
   3
   4 #include <cpPlugins/Interface/cpPlugins_Interface_Export.h>
   5 #include <cpPlugins/Interface/Object.h>
   6 #include <cpPlugins/Interface/DataObject.h>
   7 #include <cpPlugins/Interface/Parameters.h>
   8
   9 #include <cpPlugins/Interface/Image.h>
  10
  11 #define ITK_MANUAL_INSTANTIATION
  12 #include <itkProcessObject.h>
  13
  14 namespace cpPlugins
  15 {
  16   namespace Interface
  17   {
  18     /**
  19      */
  20     class cpPlugins_Interface_EXPORT ProcessObject
  21       : public Object
  22     {
  23     public:
  24       typedef ProcessObject                   Self;
  25       typedef Object                          Superclass;
  26       typedef itk::SmartPointer< Self >       Pointer;
  27       typedef itk::SmartPointer< const Self > ConstPointer;
  28
  29     public:
  30       itkTypeMacro( ProcessObject, Object );
  31
  32     public:
  33       virtual const Parameters& GetDefaultParameters( ) const;
  34       virtual void SetParameters( const Parameters& params );
  35
  36       virtual unsigned int GetNumberOfInputs( ) const;
  37       virtual unsigned int GetNumberOfOutputs( ) const;
  38
  39       virtual void SetNumberOfInputs( unsigned int n );
  40       virtual void SetNumberOfOutputs( unsigned int n );
  41
  42       virtual void SetInput( unsigned int idx, DataObject* dobj );
  43       virtual DataObject* GetOutput( unsigned int idx );
  44
  45       virtual std::string Update( );
  46       virtual void DisconnectOutputs( );
  47
  48     protected:
  49       ProcessObject( );
  50       virtual ~ProcessObject( );
  51
  52       template< class O >
  53         void _MakeOutput( unsigned int idx )
  54       {
  55         if( idx >= this->m_Outputs.size( ) )
  56           return;
  57         this->m_Outputs[ idx ] = O::New( );
  58         this->m_Outputs[ idx ]->SetSource( this );
  59       }
  60
  61       virtual std::string _GenerateData( ) = 0;
  62
  63     private:
  64       // Purposely not implemented
  65       ProcessObject( const Self& );
  66       Self& operator=( const Self& );
  67
  68     protected:
  69       itk::ProcessObject::Pointer m_RealProcessObject;
  70       Parameters m_DefaultParameters;
  71       Parameters m_Parameters;
  72
  73       std::vector< DataObject::Pointer > m_Inputs;
  74       std::vector< DataObject::Pointer > m_Outputs;
  75     };
  76
  77   } // ecapseman
  78
  79 } // ecapseman
  80
  81 // -------------------------------------------------------------------------
  82 #define cpPlugins_Image_Demangle_Methods( c )                           \
  83   std::string _DemangleImageDimension( itk::DataObject* o );            \
  84   std::string _DemangleImagePixel( unsigned int d, itk::DataObject* o );
  85
  86 // -------------------------------------------------------------------------
  87 #define cpPlugins_Image_Demangle_Methods_Code( c, f )                   \
  88   std::string c::_DemangleImageDimension( itk::DataObject* o )          \
  89   {                                                                     \
  90     std::string r = "";                                                 \
  91     if( dynamic_cast< itk::ImageBase< 1 >* >( o ) != NULL )             \
  92     {                                                                   \
  93       cpPlugins_Image_Array_Demangle(                                   \
  94         itk::Vector, float, 1, 1, o, f, r                               \
  95         );                                                              \
  96       else cpPlugins_Image_Array_Demangle(                              \
  97         itk::Vector, double, 1, 1, o, f, r                              \
  98         );                                                              \
  99       else cpPlugins_Image_Array_Demangle(                              \
 100         itk::Point, float, 1, 1, o, f, r                                \
 101         );                                                              \
 102       else cpPlugins_Image_Array_Demangle(                              \
 103         itk::Point, double, 1, 1, o, f, r                               \
 104         );                                                              \
 105       else cpPlugins_Image_Array_Demangle(                              \
 106         itk::CovariantVector, float, 1, 1, o, f, r                      \
 107         );                                                              \
 108       else cpPlugins_Image_Array_Demangle(                              \
 109         itk::CovariantVector, double, 1, 1, o, f, r                     \
 110         );                                                              \
 111       else cpPlugins_Image_Array_Demangle(                              \
 112         itk::SymmetricSecondRankTensor, float, 1, 1, o, f, r            \
 113         );                                                              \
 114       else cpPlugins_Image_Array_Demangle(                              \
 115         itk::SymmetricSecondRankTensor, double, 1, 1, o, f, r           \
 116         );                                                              \
 117       else r = this->_DemangleImagePixel( 1, o );                       \
 118     }                                                                   \
 119     else if( dynamic_cast< itk::ImageBase< 2 >* >( o ) != NULL )        \
 120     {                                                                   \
 121       cpPlugins_Image_Demangle(                                         \
 122         itk::RGBPixel< char >, 2, o, f, r                               \
 123         );                                                              \
 124       else cpPlugins_Image_Demangle(                                    \
 125         itk::RGBPixel< short >, 2, o, f, r                              \
 126         );                                                              \
 127       else cpPlugins_Image_Demangle(                                    \
 128         itk::RGBPixel< unsigned char >, 2, o, f, r                      \
 129         );                                                              \
 130       else cpPlugins_Image_Demangle(                                    \
 131         itk::RGBPixel< unsigned short >, 2, o, f, r                     \
 132         );                                                              \
 133       else cpPlugins_Image_Demangle(                                    \
 134         itk::RGBAPixel< char >, 2, o, f, r                              \
 135         );                                                              \
 136       else cpPlugins_Image_Demangle(                                    \
 137         itk::RGBAPixel< short >, 2, o, f, r                             \
 138         );                                                              \
 139       else cpPlugins_Image_Demangle(                                    \
 140         itk::RGBAPixel< unsigned char >, 2, o, f, r                     \
 141         );                                                              \
 142       else cpPlugins_Image_Demangle(                                    \
 143         itk::RGBAPixel< unsigned short >, 2, o, f, r                    \
 144         );                                                              \
 145       else cpPlugins_Image_Array_Demangle(                              \
 146         itk::Vector, float, 2, 2, o, f, r                               \
 147         );                                                              \
 148       else cpPlugins_Image_Array_Demangle(                              \
 149         itk::Vector, double, 2, 2, o, f, r                              \
 150         );                                                              \
 151       else cpPlugins_Image_Array_Demangle(                              \
 152         itk::Point, float, 2, 2, o, f, r                                \
 153         );                                                              \
 154       else cpPlugins_Image_Array_Demangle(                              \
 155         itk::Point, double, 2, 2, o, f, r                               \
 156         );                                                              \
 157       else cpPlugins_Image_Array_Demangle(                              \
 158         itk::CovariantVector, float, 2, 2, o, f, r                      \
 159         );                                                              \
 160       else cpPlugins_Image_Array_Demangle(                              \
 161         itk::CovariantVector, double, 2, 2, o, f, r                     \
 162         );                                                              \
 163       else cpPlugins_Image_Array_Demangle(                              \
 164         itk::SymmetricSecondRankTensor, float, 2, 2, o, f, r            \
 165         );                                                              \
 166       else cpPlugins_Image_Array_Demangle(                              \
 167         itk::SymmetricSecondRankTensor, double, 2, 2, o, f, r           \
 168         );                                                              \
 169       else r = this->_DemangleImagePixel( 2, o );                       \
 170     }                                                                   \
 171     else if( dynamic_cast< itk::ImageBase< 3 >* >( o ) != NULL )        \
 172     {                                                                   \
 173       cpPlugins_Image_Demangle(                                         \
 174         itk::RGBPixel< char >, 3, o, f, r                               \
 175         );                                                              \
 176       else cpPlugins_Image_Demangle(                                    \
 177         itk::RGBPixel< short >, 3, o, f, r                              \
 178         );                                                              \
 179       else cpPlugins_Image_Demangle(                                    \
 180         itk::RGBPixel< unsigned char >, 3, o, f, r                      \
 181         );                                                              \
 182       else cpPlugins_Image_Demangle(                                    \
 183         itk::RGBPixel< unsigned short >, 3, o, f, r                     \
 184         );                                                              \
 185       else cpPlugins_Image_Demangle(                                    \
 186         itk::RGBAPixel< char >, 3, o, f, r                              \
 187         );                                                              \
 188       else cpPlugins_Image_Demangle(                                    \
 189         itk::RGBAPixel< short >, 3, o, f, r                             \
 190         );                                                              \
 191       else cpPlugins_Image_Demangle(                                    \
 192         itk::RGBAPixel< unsigned char >, 3, o, f, r                     \
 193         );                                                              \
 194       else cpPlugins_Image_Demangle(                                    \
 195         itk::RGBAPixel< unsigned short >, 3, o, f, r                    \
 196         );                                                              \
 197       else cpPlugins_Image_Array_Demangle(                              \
 198         itk::Vector, float, 3, 3, o, f, r                               \
 199         );                                                              \
 200       else cpPlugins_Image_Array_Demangle(                              \
 201         itk::Vector, double, 3, 3, o, f, r                              \
 202         );                                                              \
 203       else cpPlugins_Image_Array_Demangle(                              \
 204         itk::Point, float, 3, 3, o, f, r                                \
 205         );                                                              \
 206       else cpPlugins_Image_Array_Demangle(                              \
 207         itk::Point, double, 3, 3, o, f, r                               \
 208         );                                                              \
 209       else cpPlugins_Image_Array_Demangle(                              \
 210         itk::CovariantVector, float, 3, 3, o, f, r                      \
 211         );                                                              \
 212       else cpPlugins_Image_Array_Demangle(                              \
 213         itk::CovariantVector, double, 3, 3, o, f, r                     \
 214         );                                                              \
 215       else cpPlugins_Image_Array_Demangle(                              \
 216         itk::SymmetricSecondRankTensor, float, 3, 3, o, f, r            \
 217         );                                                              \
 218       else cpPlugins_Image_Array_Demangle(                              \
 219         itk::SymmetricSecondRankTensor, double, 3, 3, o, f, r           \
 220         );                                                              \
 221       else cpPlugins_Image_Demangle(                                    \
 222         itk::DiffusionTensor3D< float >, 3, o, f, r                     \
 223         );                                                              \
 224       else cpPlugins_Image_Demangle(                                    \
 225         itk::DiffusionTensor3D< double >, 3, o, f, r                    \
 226         );                                                              \
 227       else r = this->_DemangleImagePixel( 3, o );                       \
 228     }                                                                   \
 229     else if( dynamic_cast< itk::ImageBase< 4 >* >( o ) != NULL )        \
 230     {                                                                   \
 231       cpPlugins_Image_Demangle(                                         \
 232         itk::RGBPixel< char >, 4, o, f, r                               \
 233         );                                                              \
 234       else cpPlugins_Image_Demangle(                                    \
 235         itk::RGBPixel< short >, 4, o, f, r                              \
 236         );                                                              \
 237       else cpPlugins_Image_Demangle(                                    \
 238         itk::RGBPixel< unsigned char >, 4, o, f, r                      \
 239         );                                                              \
 240       else cpPlugins_Image_Demangle(                                    \
 241         itk::RGBPixel< unsigned short >, 4, o, f, r                     \
 242         );                                                              \
 243       else cpPlugins_Image_Demangle(                                    \
 244         itk::RGBAPixel< char >, 4, o, f, r                              \
 245         );                                                              \
 246       else cpPlugins_Image_Demangle(                                    \
 247         itk::RGBAPixel< short >, 4, o, f, r                             \
 248         );                                                              \
 249       else cpPlugins_Image_Demangle(                                    \
 250         itk::RGBAPixel< unsigned char >, 4, o, f, r                     \
 251         );                                                              \
 252       else cpPlugins_Image_Demangle(                                    \
 253         itk::RGBAPixel< unsigned short >, 4, o, f, r                    \
 254         );                                                              \
 255       else cpPlugins_Image_Array_Demangle(                              \
 256         itk::Vector, float, 4, 4, o, f, r                               \
 257         );                                                              \
 258       else cpPlugins_Image_Array_Demangle(                              \
 259         itk::Vector, double, 4, 4, o, f, r                              \
 260         );                                                              \
 261       else cpPlugins_Image_Array_Demangle(                              \
 262         itk::Point, float, 4, 4, o, f, r                                \
 263         );                                                              \
 264       else cpPlugins_Image_Array_Demangle(                              \
 265         itk::Point, double, 4, 4, o, f, r                               \
 266         );                                                              \
 267       else cpPlugins_Image_Array_Demangle(                              \
 268         itk::CovariantVector, float, 4, 4, o, f, r                      \
 269         );                                                              \
 270       else cpPlugins_Image_Array_Demangle(                              \
 271         itk::CovariantVector, double, 4, 4, o, f, r                     \
 272         );                                                              \
 273       else cpPlugins_Image_Array_Demangle(                              \
 274         itk::SymmetricSecondRankTensor, float, 4, 4, o, f, r            \
 275         );                                                              \
 276       else cpPlugins_Image_Array_Demangle(                              \
 277         itk::SymmetricSecondRankTensor, double, 4, 4, o, f, r           \
 278         );                                                              \
 279       else r = this->_DemangleImagePixel( 4, o );                       \
 280     }                                                                   \
 281     else                                                                \
 282       r =                                                               \
 283         std::string( #c ) +                                             \
 284         std::string( ": Image dimension not supported." );              \
 285     return( r );                                                        \
 286   }                                                                     \
 287   std::string c::_DemangleImagePixel(                                   \
 288     unsigned int d, itk::DataObject* o                                  \
 289     )                                                                   \
 290   {                                                                     \
 291     std::string r = "";                                                 \
 292     if( d == 1 )                                                        \
 293     {                                                                   \
 294       cpPlugins_Image_Demangle(                                         \
 295         char, 1, o, f, r                                                \
 296         );                                                              \
 297       else cpPlugins_Image_Demangle(                                    \
 298         short, 1, o, f, r                                               \
 299         );                                                              \
 300       else cpPlugins_Image_Demangle(                                    \
 301         int, 1, o, f, r                                                 \
 302         );                                                              \
 303       else cpPlugins_Image_Demangle(                                    \
 304         long, 1, o, f, r                                                \
 305         );                                                              \
 306       else cpPlugins_Image_Demangle(                                    \
 307         unsigned char, 1, o, f, r                                       \
 308         );                                                              \
 309       else cpPlugins_Image_Demangle(                                    \
 310         unsigned short, 1, o, f, r                                      \
 311         );                                                              \
 312       else cpPlugins_Image_Demangle(                                    \
 313         unsigned int, 1, o, f, r                                        \
 314         );                                                              \
 315       else cpPlugins_Image_Demangle(                                    \
 316         unsigned long, 1, o, f, r                                       \
 317         );                                                              \
 318       else cpPlugins_Image_Demangle(                                    \
 319         float, 1, o, f, r                                               \
 320         );                                                              \
 321       else cpPlugins_Image_Demangle(                                    \
 322         double, 1, o, f, r                                              \
 323         );                                                              \
 324       else cpPlugins_Image_Demangle(                                    \
 325         std::complex< float >, 1, o, f, r                               \
 326         );                                                              \
 327       else cpPlugins_Image_Demangle(                                    \
 328         std::complex< double >, 1, o, f, r                              \
 329         );                                                              \
 330       else cpPlugins_Image_Demangle(                                    \
 331         itk::Offset< 1 >, 1, o, f, r                                    \
 332         );                                                              \
 333       else r = std::string( #c ) + std::string( ": Image type." );      \
 334     }                                                                   \
 335     else if( d == 2 )                                                   \
 336     {                                                                   \
 337       cpPlugins_Image_Demangle(                                         \
 338         char, 2, o, f, r                                                \
 339         );                                                              \
 340       else cpPlugins_Image_Demangle(                                    \
 341         short, 2, o, f, r                                               \
 342         );                                                              \
 343       else cpPlugins_Image_Demangle(                                    \
 344         int, 2, o, f, r                                                 \
 345         );                                                              \
 346       else cpPlugins_Image_Demangle(                                    \
 347         long, 2, o, f, r                                                \
 348         );                                                              \
 349       else cpPlugins_Image_Demangle(                                    \
 350         unsigned char, 2, o, f, r                                       \
 351         );                                                              \
 352       else cpPlugins_Image_Demangle(                                    \
 353         unsigned short, 2, o, f, r                                      \
 354         );                                                              \
 355       else cpPlugins_Image_Demangle(                                    \
 356         unsigned int, 2, o, f, r                                        \
 357         );                                                              \
 358       else cpPlugins_Image_Demangle(                                    \
 359         unsigned long, 2, o, f, r                                       \
 360         );                                                              \
 361       else cpPlugins_Image_Demangle(                                    \
 362         float, 2, o, f, r                                               \
 363         );                                                              \
 364       else cpPlugins_Image_Demangle(                                    \
 365         double, 2, o, f, r                                              \
 366         );                                                              \
 367       else cpPlugins_Image_Demangle(                                    \
 368         std::complex< float >, 2, o, f, r                               \
 369         );                                                              \
 370       else cpPlugins_Image_Demangle(                                    \
 371         std::complex< double >, 2, o, f, r                              \
 372         );                                                              \
 373       else cpPlugins_Image_Demangle(                                    \
 374         itk::Offset< 2 >, 2, o, f, r                                    \
 375         );                                                              \
 376       else r = std::string( #c ) + std::string( ": Image type." );      \
 377     }                                                                   \
 378     else if( d == 3 )                                                   \
 379     {                                                                   \
 380       cpPlugins_Image_Demangle(                                         \
 381         char, 3, o, f, r                                                \
 382         );                                                              \
 383       else cpPlugins_Image_Demangle(                                    \
 384         short, 3, o, f, r                                               \
 385         );                                                              \
 386       else cpPlugins_Image_Demangle(                                    \
 387         int, 3, o, f, r                                                 \
 388         );                                                              \
 389       else cpPlugins_Image_Demangle(                                    \
 390         long, 3, o, f, r                                                \
 391         );                                                              \
 392       else cpPlugins_Image_Demangle(                                    \
 393         unsigned char, 3, o, f, r                                       \
 394         );                                                              \
 395       else cpPlugins_Image_Demangle(                                    \
 396         unsigned short, 3, o, f, r                                      \
 397         );                                                              \
 398       else cpPlugins_Image_Demangle(                                    \
 399         unsigned int, 3, o, f, r                                        \
 400         );                                                              \
 401       else cpPlugins_Image_Demangle(                                    \
 402         unsigned long, 3, o, f, r                                       \
 403         );                                                              \
 404       else cpPlugins_Image_Demangle(                                    \
 405         float, 3, o, f, r                                               \
 406         );                                                              \
 407       else cpPlugins_Image_Demangle(                                    \
 408         double, 3, o, f, r                                              \
 409         );                                                              \
 410       else cpPlugins_Image_Demangle(                                    \
 411         std::complex< float >, 3, o, f, r                               \
 412         );                                                              \
 413       else cpPlugins_Image_Demangle(                                    \
 414         std::complex< double >, 3, o, f, r                              \
 415         );                                                              \
 416       else cpPlugins_Image_Demangle(                                    \
 417         itk::Offset< 3 >, 3, o, f, r                                    \
 418         );                                                              \
 419       else r = std::string( #c ) + std::string( ": Image type." );      \
 420     }                                                                   \
 421     else if( d == 4 )                                                   \
 422     {                                                                   \
 423       cpPlugins_Image_Demangle(                                         \
 424         char, 4, o, f, r                                                \
 425         );                                                              \
 426       else cpPlugins_Image_Demangle(                                    \
 427         short, 4, o, f, r                                               \
 428         );                                                              \
 429       else cpPlugins_Image_Demangle(                                    \
 430         int, 4, o, f, r                                                 \
 431         );                                                              \
 432       else cpPlugins_Image_Demangle(                                    \
 433         long, 4, o, f, r                                                \
 434         );                                                              \
 435       else cpPlugins_Image_Demangle(                                    \
 436         unsigned char, 4, o, f, r                                       \
 437         );                                                              \
 438       else cpPlugins_Image_Demangle(                                    \
 439         unsigned short, 4, o, f, r                                      \
 440         );                                                              \
 441       else cpPlugins_Image_Demangle(                                    \
 442         unsigned int, 4, o, f, r                                        \
 443         );                                                              \
 444       else cpPlugins_Image_Demangle(                                    \
 445         unsigned long, 4, o, f, r                                       \
 446         );                                                              \
 447       else cpPlugins_Image_Demangle(                                    \
 448         float, 4, o, f, r                                               \
 449         );                                                              \
 450       else cpPlugins_Image_Demangle(                                    \
 451         double, 4, o, f, r                                              \
 452         );                                                              \
 453       else cpPlugins_Image_Demangle(                                    \
 454         std::complex< float >, 4, o, f, r                               \
 455         );                                                              \
 456       else cpPlugins_Image_Demangle(                                    \
 457         std::complex< double >, 4, o, f, r                              \
 458         );                                                              \
 459       else cpPlugins_Image_Demangle(                                    \
 460         itk::Offset< 4 >, 4, o, f, r                                    \
 461         );                                                              \
 462       else r = std::string( #c ) + std::string( ": Image type." );      \
 463     }                                                                   \
 464     else                                                                \
 465       r =                                                               \
 466         std::string( #c ) +                                             \
 467         std::string( ": Image dimension not supported." );              \
 468     return( r );                                                        \
 469   }
 470
 471 // -------------------------------------------------------------------------
 472 #define cpPlugins_Image_Demangle_Methods_Code_Only_Scalars( c, f )      \
 473   std::string c::_DemangleImageDimension( itk::DataObject* o )          \
 474   {                                                                     \
 475     std::string r = "";                                                 \
 476     if( dynamic_cast< itk::ImageBase< 1 >* >( o ) != NULL )             \
 477       r = this->_DemangleImagePixel( 1, o );                            \
 478     else if( dynamic_cast< itk::ImageBase< 2 >* >( o ) != NULL )        \
 479       r = this->_DemangleImagePixel( 2, o );                            \
 480     else if( dynamic_cast< itk::ImageBase< 3 >* >( o ) != NULL )        \
 481       r = this->_DemangleImagePixel( 3, o );                            \
 482     else if( dynamic_cast< itk::ImageBase< 4 >* >( o ) != NULL )        \
 483       r = this->_DemangleImagePixel( 4, o );                            \
 484     else                                                                \
 485       r =                                                               \
 486         std::string( #c ) +                                             \
 487         std::string( ": Image dimension not supported." );              \
 488     return( r );                                                        \
 489   }                                                                     \
 490   std::string c::_DemangleImagePixel(                                   \
 491     unsigned int d, itk::DataObject* o                                  \
 492     )                                                                   \
 493   {                                                                     \
 494     std::string r = "";                                                 \
 495     if( d == 1 )                                                        \
 496     {                                                                   \
 497       cpPlugins_Image_Demangle(                                         \
 498         char, 1, o, f, r                                                \
 499         );                                                              \
 500       else cpPlugins_Image_Demangle(                                    \
 501         short, 1, o, f, r                                               \
 502         );                                                              \
 503       else cpPlugins_Image_Demangle(                                    \
 504         int, 1, o, f, r                                                 \
 505         );                                                              \
 506       else cpPlugins_Image_Demangle(                                    \
 507         long, 1, o, f, r                                                \
 508         );                                                              \
 509       else cpPlugins_Image_Demangle(                                    \
 510         unsigned char, 1, o, f, r                                       \
 511         );                                                              \
 512       else cpPlugins_Image_Demangle(                                    \
 513         unsigned short, 1, o, f, r                                      \
 514         );                                                              \
 515       else cpPlugins_Image_Demangle(                                    \
 516         unsigned int, 1, o, f, r                                        \
 517         );                                                              \
 518       else cpPlugins_Image_Demangle(                                    \
 519         unsigned long, 1, o, f, r                                       \
 520         );                                                              \
 521       else cpPlugins_Image_Demangle(                                    \
 522         float, 1, o, f, r                                               \
 523         );                                                              \
 524       else cpPlugins_Image_Demangle(                                    \
 525         double, 1, o, f, r                                              \
 526         );                                                              \
 527       else r = std::string( #c ) + std::string( ": Image type." );      \
 528     }                                                                   \
 529     else if( d == 2 )                                                   \
 530     {                                                                   \
 531       cpPlugins_Image_Demangle(                                         \
 532         char, 2, o, f, r                                                \
 533         );                                                              \
 534       else cpPlugins_Image_Demangle(                                    \
 535         short, 2, o, f, r                                               \
 536         );                                                              \
 537       else cpPlugins_Image_Demangle(                                    \
 538         int, 2, o, f, r                                                 \
 539         );                                                              \
 540       else cpPlugins_Image_Demangle(                                    \
 541         long, 2, o, f, r                                                \
 542         );                                                              \
 543       else cpPlugins_Image_Demangle(                                    \
 544         unsigned char, 2, o, f, r                                       \
 545         );                                                              \
 546       else cpPlugins_Image_Demangle(                                    \
 547         unsigned short, 2, o, f, r                                      \
 548         );                                                              \
 549       else cpPlugins_Image_Demangle(                                    \
 550         unsigned int, 2, o, f, r                                        \
 551         );                                                              \
 552       else cpPlugins_Image_Demangle(                                    \
 553         unsigned long, 2, o, f, r                                       \
 554         );                                                              \
 555       else cpPlugins_Image_Demangle(                                    \
 556         float, 2, o, f, r                                               \
 557         );                                                              \
 558       else cpPlugins_Image_Demangle(                                    \
 559         double, 2, o, f, r                                              \
 560         );                                                              \
 561       else r = std::string( #c ) + std::string( ": Image type." );      \
 562     }                                                                   \
 563     else if( d == 3 )                                                   \
 564     {                                                                   \
 565       cpPlugins_Image_Demangle(                                         \
 566         char, 3, o, f, r                                                \
 567         );                                                              \
 568       else cpPlugins_Image_Demangle(                                    \
 569         short, 3, o, f, r                                               \
 570         );                                                              \
 571       else cpPlugins_Image_Demangle(                                    \
 572         int, 3, o, f, r                                                 \
 573         );                                                              \
 574       else cpPlugins_Image_Demangle(                                    \
 575         long, 3, o, f, r                                                \
 576         );                                                              \
 577       else cpPlugins_Image_Demangle(                                    \
 578         unsigned char, 3, o, f, r                                       \
 579         );                                                              \
 580       else cpPlugins_Image_Demangle(                                    \
 581         unsigned short, 3, o, f, r                                      \
 582         );                                                              \
 583       else cpPlugins_Image_Demangle(                                    \
 584         unsigned int, 3, o, f, r                                        \
 585         );                                                              \
 586       else cpPlugins_Image_Demangle(                                    \
 587         unsigned long, 3, o, f, r                                       \
 588         );                                                              \
 589       else cpPlugins_Image_Demangle(                                    \
 590         float, 3, o, f, r                                               \
 591         );                                                              \
 592       else cpPlugins_Image_Demangle(                                    \
 593         double, 3, o, f, r                                              \
 594         );                                                              \
 595       else r = std::string( #c ) + std::string( ": Image type." );      \
 596     }                                                                   \
 597     else if( d == 4 )                                                   \
 598     {                                                                   \
 599       cpPlugins_Image_Demangle(                                         \
 600         char, 4, o, f, r                                                \
 601         );                                                              \
 602       else cpPlugins_Image_Demangle(                                    \
 603         short, 4, o, f, r                                               \
 604         );                                                              \
 605       else cpPlugins_Image_Demangle(                                    \
 606         int, 4, o, f, r                                                 \
 607         );                                                              \
 608       else cpPlugins_Image_Demangle(                                    \
 609         long, 4, o, f, r                                                \
 610         );                                                              \
 611       else cpPlugins_Image_Demangle(                                    \
 612         unsigned char, 4, o, f, r                                       \
 613         );                                                              \
 614       else cpPlugins_Image_Demangle(                                    \
 615         unsigned short, 4, o, f, r                                      \
 616         );                                                              \
 617       else cpPlugins_Image_Demangle(                                    \
 618         unsigned int, 4, o, f, r                                        \
 619         );                                                              \
 620       else cpPlugins_Image_Demangle(                                    \
 621         unsigned long, 4, o, f, r                                       \
 622         );                                                              \
 623       else cpPlugins_Image_Demangle(                                    \
 624         float, 4, o, f, r                                               \
 625         );                                                              \
 626       else cpPlugins_Image_Demangle(                                    \
 627         double, 4, o, f, r                                              \
 628         );                                                              \
 629       else r = std::string( #c ) + std::string( ": Image type." );      \
 630     }                                                                   \
 631     else                                                                \
 632       r =                                                               \
 633         std::string( #c ) +                                             \
 634         std::string( ": Image dimension not supported." );              \
 635     return( r );                                                        \
 636   }
 637
 638 #endif // __CPPLUGINS__INTERFACE__PROCESSOBJECT__H__
 639
 640 // eof - $RCSfile$