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