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