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