lib/cpPlugins/Plugins/ImageReader.cxx

   1 #include <cpPlugins/Plugins/ImageReader.h>
   2 #include <cpPlugins/Interface/Image.h>
   3
   4 #include <complex>
   5 #include <set>
   6
   7 #define ITK_MANUAL_INSTANTIATION
   8 #include <itkImage.h>
   9
  10 #include <itkCovariantVector.h>
  11 #include <itkDiffusionTensor3D.h>
  12 #include <itkPoint.h>
  13 #include <itkRGBPixel.h>
  14 #include <itkRGBAPixel.h>
  15 #include <itkSymmetricSecondRankTensor.h>
  16 #include <itkVector.h>
  17
  18 #undef ITK_MANUAL_INSTANTIATION
  19 #include <itkImageFileReader.h>
  20 #include <itkImageSeriesReader.h>
  21
  22 // -------------------------------------------------------------------------
  23 cpPlugins::Plugins::ImageReader::
  24 ImageReader( )
  25   : Superclass( )
  26 {
  27   this->m_ClassName = "cpPlugins::ImageReader";
  28   this->m_ClassCategory = "ImageReader";
  29
  30   this->SetNumberOfOutputs( 1 );
  31   this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
  32
  33   using namespace cpPlugins::Interface;
  34   this->m_DefaultParameters.Configure( Parameters::StringList, "FileNames" );
  35   this->m_Parameters = this->m_DefaultParameters;
  36 }
  37
  38 // -------------------------------------------------------------------------
  39 cpPlugins::Plugins::ImageReader::
  40 ~ImageReader( )
  41 {
  42 }
  43
  44 // -------------------------------------------------------------------------
  45 std::string cpPlugins::Plugins::ImageReader::
  46 _GenerateData( )
  47 {
  48   // Get filenames
  49   TStringList names;
  50   this->m_Parameters.GetValueAsStringList( names, "FileNames" );
  51
  52   std::string r = "";
  53   if( names.size( ) >= 1 )
  54   {
  55     // Guess image properties
  56     itk::ImageIOBase::Pointer io =
  57       itk::ImageIOFactory::CreateImageIO(
  58         names[ 0 ].c_str( ),
  59         itk::ImageIOFactory::ReadMode
  60         );
  61     if( io.IsNotNull( ) )
  62     {
  63       io->SetFileName( names[ 0 ] );
  64       io->ReadImageInformation( );
  65       if( names.size( ) == 1 )
  66       {
  67         switch( io->GetNumberOfDimensions( ) )
  68         {
  69         case 2: r = this->_GD0< 2 >( io, names ); break;
  70         case 3: r = this->_GD0< 3 >( io, names ); break;
  71         case 4: r = this->_GD0< 4 >( io, names ); break;
  72         default:
  73           r = "ImageReader: Single image dimension not supported.";
  74           break;
  75         } // hctiws
  76       }
  77       else if( names.size( ) > 1 )
  78       {
  79         switch( io->GetNumberOfDimensions( ) )
  80         {
  81         case 1: r = this->_GD0< 2 >( io, names ); break;
  82         case 2: r = this->_GD0< 3 >( io, names ); break;
  83         case 3: r = this->_GD0< 4 >( io, names ); break;
  84         default:
  85           r = "ImageReader: Multiple images dimension not supported.";
  86           break;
  87         } // hctiws
  88
  89       } // fi
  90     }
  91     else
  92       r = "ImageReader: Could not CreateImageIO for \"" + names[ 0 ] + "\"";
  93   }
  94   else
  95     r = "No image files given";
  96   return( r );
  97 }
  98
  99 // -------------------------------------------------------------------------
 100 template< unsigned int D >
 101 std::string cpPlugins::Plugins::ImageReader::
 102 _GD0( itk::ImageIOBase* io, const TStringList& names )
 103 {
 104   itk::ImageIOBase::IOComponentType ct = io->GetComponentType( );
 105   itk::ImageIOBase::IOPixelType pt = io->GetPixelType( );
 106   std::string r = "";
 107
 108   if( pt == itk::ImageIOBase::SCALAR )
 109   {
 110     switch( ct )
 111     {
 112     case itk::ImageIOBase::UCHAR:
 113       r = this->_RealGD< unsigned char, D >( names );
 114       break;
 115     case itk::ImageIOBase::CHAR:
 116       r = this->_RealGD< char, D >( names );
 117       break;
 118     case itk::ImageIOBase::USHORT:
 119       r = this->_RealGD< unsigned short, D >( names );
 120       break;
 121     case itk::ImageIOBase::SHORT:
 122       r = this->_RealGD< short, D >( names );
 123       break;
 124     case itk::ImageIOBase::UINT:
 125       r = this->_RealGD< unsigned int, D >( names );
 126       break;
 127     case itk::ImageIOBase::INT:
 128       r = this->_RealGD< int, D >( names );
 129       break;
 130     case itk::ImageIOBase::ULONG:
 131       r = this->_RealGD< unsigned long, D >( names );
 132       break;
 133     case itk::ImageIOBase::LONG:
 134       r = this->_RealGD< long, D >( names );
 135       break;
 136     case itk::ImageIOBase::FLOAT:
 137       r = this->_RealGD< float, D >( names );
 138       break;
 139     case itk::ImageIOBase::DOUBLE:
 140       r = this->_RealGD< double, D >( names );
 141       break;
 142     default:
 143       r = "ImageReader: Scalar pixel type not supported.";
 144       break;
 145     } // hctiws
 146   }
 147   else if( pt == itk::ImageIOBase::RGB )
 148   {
 149     if( D == 2 )
 150     {
 151       switch( ct )
 152       {
 153       case itk::ImageIOBase::UCHAR:
 154         r = this->_RealGD< itk::RGBPixel< unsigned char >, 2 >( names );
 155         break;
 156       case itk::ImageIOBase::CHAR:
 157         r = this->_RealGD< itk::RGBPixel< char >, 2 >( names );
 158         break;
 159       case itk::ImageIOBase::USHORT:
 160         r = this->_RealGD< itk::RGBPixel< unsigned short >, 2 >( names );
 161         break;
 162       case itk::ImageIOBase::SHORT:
 163         r = this->_RealGD< itk::RGBPixel< short >, 2 >( names );
 164         break;
 165       default:
 166         r = "ImageReader: Scalar pixel type not supported.";
 167         break;
 168       } // hctiws
 169     }
 170     else if( D == 3 )
 171     {
 172       switch( ct )
 173       {
 174       case itk::ImageIOBase::UCHAR:
 175         r = this->_RealGD< itk::RGBPixel< unsigned char >, 3 >( names );
 176         break;
 177       case itk::ImageIOBase::CHAR:
 178         r = this->_RealGD< itk::RGBPixel< char >, 3 >( names );
 179         break;
 180       case itk::ImageIOBase::USHORT:
 181         r = this->_RealGD< itk::RGBPixel< unsigned short >, 3 >( names );
 182         break;
 183       case itk::ImageIOBase::SHORT:
 184         r = this->_RealGD< itk::RGBPixel< short >, 3 >( names );
 185         break;
 186       default:
 187         r = "ImageReader: Scalar pixel type not supported.";
 188         break;
 189       } // hctiws
 190     }
 191     else if( D == 4 )
 192     {
 193       switch( ct )
 194       {
 195       case itk::ImageIOBase::UCHAR:
 196         r = this->_RealGD< itk::RGBPixel< unsigned char >, 4 >( names );
 197         break;
 198       case itk::ImageIOBase::CHAR:
 199         r = this->_RealGD< itk::RGBPixel< char >, 4 >( names );
 200         break;
 201       case itk::ImageIOBase::USHORT:
 202         r = this->_RealGD< itk::RGBPixel< unsigned short >, 4 >( names );
 203         break;
 204       case itk::ImageIOBase::SHORT:
 205         r = this->_RealGD< itk::RGBPixel< short >, 4 >( names );
 206         break;
 207       default:
 208         r = "ImageReader: Scalar pixel type not supported.";
 209         break;
 210       } // hctiws
 211
 212     } // fi
 213   }
 214   else if( pt == itk::ImageIOBase::RGBA )
 215   {
 216     if( D == 2 )
 217     {
 218       switch( ct )
 219       {
 220       case itk::ImageIOBase::UCHAR:
 221         r = this->_RealGD< itk::RGBAPixel< unsigned char >, 2 >( names );
 222         break;
 223       case itk::ImageIOBase::CHAR:
 224         r = this->_RealGD< itk::RGBAPixel< char >, 2 >( names );
 225         break;
 226       case itk::ImageIOBase::USHORT:
 227         r = this->_RealGD< itk::RGBAPixel< unsigned short >, 2 >( names );
 228         break;
 229       case itk::ImageIOBase::SHORT:
 230         r = this->_RealGD< itk::RGBAPixel< short >, 2 >( names );
 231         break;
 232       default:
 233         r = "ImageReader: Scalar pixel type not supported.";
 234         break;
 235       } // hctiws
 236     }
 237     else if( D == 3 )
 238     {
 239       switch( ct )
 240       {
 241       case itk::ImageIOBase::UCHAR:
 242         r = this->_RealGD< itk::RGBAPixel< unsigned char >, 3 >( names );
 243         break;
 244       case itk::ImageIOBase::CHAR:
 245         r = this->_RealGD< itk::RGBAPixel< char >, 3 >( names );
 246         break;
 247       case itk::ImageIOBase::USHORT:
 248         r = this->_RealGD< itk::RGBAPixel< unsigned short >, 3 >( names );
 249         break;
 250       case itk::ImageIOBase::SHORT:
 251         r = this->_RealGD< itk::RGBAPixel< short >, 3 >( names );
 252         break;
 253       default:
 254         r = "ImageReader: Scalar pixel type not supported.";
 255         break;
 256       } // hctiws
 257     }
 258     else if( D == 4 )
 259     {
 260       switch( ct )
 261       {
 262       case itk::ImageIOBase::UCHAR:
 263         r = this->_RealGD< itk::RGBAPixel< unsigned char >, 4 >( names );
 264         break;
 265       case itk::ImageIOBase::CHAR:
 266         r = this->_RealGD< itk::RGBAPixel< char >, 4 >( names );
 267         break;
 268       case itk::ImageIOBase::USHORT:
 269         r = this->_RealGD< itk::RGBAPixel< unsigned short >, 4 >( names );
 270         break;
 271       case itk::ImageIOBase::SHORT:
 272         r = this->_RealGD< itk::RGBAPixel< short >, 4 >( names );
 273         break;
 274       default:
 275         r = "ImageReader: Scalar pixel type not supported.";
 276         break;
 277       } // hctiws
 278
 279     } // fi
 280   }
 281   else if( pt == itk::ImageIOBase::OFFSET )
 282   {
 283     switch( D )
 284     {
 285     case 2:
 286       r = this->_RealGD< itk::Offset< 2 >, 2 >( names );
 287       break;
 288     case 3:
 289       r = this->_RealGD< itk::Offset< 3 >, 3 >( names );
 290       break;
 291     case 4:
 292       r = this->_RealGD< itk::Offset< 4 >, 4 >( names );
 293       break;
 294     default:
 295       r = "ImageReader: Offset pixel dimension not supported.";
 296       break;
 297     } // hctiws
 298   }
 299   else if( pt == itk::ImageIOBase::VECTOR )
 300   {
 301     switch( ct )
 302     {
 303     case itk::ImageIOBase::FLOAT:
 304       r = this->_RealGD< itk::Vector< float, D >, D >( names );
 305       break;
 306     case itk::ImageIOBase::DOUBLE:
 307       r = this->_RealGD< itk::Vector< double, D >, D >( names );
 308       break;
 309     default:
 310       r = "ImageReader: Vector type not supported.";
 311       break;
 312     } // hctiws
 313   }
 314   else if( pt == itk::ImageIOBase::POINT )
 315   {
 316     switch( ct )
 317     {
 318     case itk::ImageIOBase::FLOAT:
 319       r = this->_RealGD< itk::Point< float, D >, D >( names );
 320       break;
 321     case itk::ImageIOBase::DOUBLE:
 322       r = this->_RealGD< itk::Point< double, D >, D >( names );
 323       break;
 324     default:
 325       r = "ImageReader: Point type not supported.";
 326       break;
 327     } // hctiws
 328   }
 329   else if( pt == itk::ImageIOBase::COVARIANTVECTOR )
 330   {
 331     switch( ct )
 332     {
 333     case itk::ImageIOBase::FLOAT:
 334       r = this->_RealGD< itk::CovariantVector< float, D >, D >( names );
 335       break;
 336     case itk::ImageIOBase::DOUBLE:
 337       r = this->_RealGD< itk::CovariantVector< double, D >, D >( names );
 338       break;
 339     default:
 340       r = "ImageReader: Vector type not supported.";
 341       break;
 342     } // hctiws
 343   }
 344   else if( pt == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR )
 345   {
 346     switch( ct )
 347     {
 348     case itk::ImageIOBase::FLOAT:
 349       r =
 350         this->_RealGD< itk::SymmetricSecondRankTensor< float, D >, D >(
 351           names
 352           );
 353       break;
 354     case itk::ImageIOBase::DOUBLE:
 355       r =
 356         this->_RealGD< itk::SymmetricSecondRankTensor< double, D >, D >(
 357           names
 358           );
 359       break;
 360     default:
 361       r = "ImageReader: Vector type not supported.";
 362       break;
 363     } // hctiws
 364   }
 365   else if( pt == itk::ImageIOBase::DIFFUSIONTENSOR3D )
 366   {
 367     if( D == 3 )
 368     {
 369       switch( ct )
 370       {
 371       case itk::ImageIOBase::FLOAT:
 372         r = this->_RealGD< itk::DiffusionTensor3D< float >, 3 >( names );
 373         break;
 374       case itk::ImageIOBase::DOUBLE:
 375         r = this->_RealGD< itk::DiffusionTensor3D< double >, 3 >( names );
 376         break;
 377       default:
 378         r = "ImageReader: Diffusion tensor type not supported.";
 379         break;
 380       } // hctiws
 381     }
 382     else
 383       r = "ImageReader: Diffusion tensor dimension not supported.";
 384   }
 385   else if( pt == itk::ImageIOBase::COMPLEX )
 386   {
 387     switch( ct )
 388     {
 389     case itk::ImageIOBase::FLOAT:
 390       r = this->_RealGD< std::complex< float >, D >( names );
 391       break;
 392     case itk::ImageIOBase::DOUBLE:
 393       r = this->_RealGD< std::complex< double >, D >( names );
 394       break;
 395     default:
 396       r = "ImageReader: Complex type not supported.";
 397       break;
 398     } // hctiws
 399   }
 400   else
 401     r = "ImageReader: Image pixel type not yet supported.";
 402   /* TODO
 403      itk::ImageIOBase::FIXEDARRAY
 404      itk::ImageIOBase::MATRIX
 405   */
 406
 407   return( r );
 408 }
 409
 410 // -------------------------------------------------------------------------
 411 template< class P, unsigned int D >
 412 std::string cpPlugins::Plugins::ImageReader::
 413 _RealGD( const TStringList& names )
 414 {
 415   typedef itk::Image< P, D > _I;
 416
 417   std::string r = "";
 418   if( names.size( ) == 1 )
 419   {
 420     // Read single image
 421     typedef itk::ImageFileReader< _I > _SR;
 422     _SR* reader =
 423       dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
 424     if( reader == NULL )
 425     {
 426       this->m_RealProcessObject = _SR::New( );
 427       reader =
 428         dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
 429
 430     } // fi
 431     reader->SetFileName( names[ 0 ] );
 432     try
 433     {
 434       reader->Update( );
 435       cpPlugins::Interface::Image* out =
 436         this->_Output< cpPlugins::Interface::Image >( 0 );
 437       if( out != NULL )
 438         out->SetITKImage< _I >( reader->GetOutput( ) );
 439       else
 440         r = "ImageReader: output not correctly created.";
 441     }
 442     catch( itk::ExceptionObject& err )
 443     {
 444       r = "ImageReader: " + std::string( err.GetDescription( ) );
 445       cpPlugins::Interface::Image* out =
 446         this->_Output< cpPlugins::Interface::Image >( 0 );
 447       if( out != NULL )
 448         out->SetITKImage< _I >( NULL );
 449       else
 450         r = "ImageReader: output not correctly created.";
 451
 452     } // yrt
 453   }
 454   else if( names.size( ) > 1 )
 455   {
 456     // Read image series
 457     std::set< std::string > ordered_names;
 458     for( unsigned int i = 0; i < names.size( ); ++i )
 459       ordered_names.insert( names[ i ] );
 460
 461     typedef itk::ImageSeriesReader< _I > _MR;
 462     _MR* reader =
 463       dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
 464     if( reader == NULL )
 465     {
 466       this->m_RealProcessObject = _MR::New( );
 467       reader =
 468         dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
 469
 470     } // fi
 471     std::set< std::string >::const_iterator fnIt = ordered_names.begin( );
 472     for( ; fnIt != ordered_names.end( ); ++fnIt )
 473       reader->AddFileName( *fnIt );
 474     try
 475     {
 476       reader->Update( );
 477       cpPlugins::Interface::Image* out =
 478         this->_Output< cpPlugins::Interface::Image >( 0 );
 479       if( out != NULL )
 480         out->SetITKImage< _I >( reader->GetOutput( ) );
 481       else
 482         r = "ImageReader: output not correctly created.";
 483     }
 484     catch( itk::ExceptionObject& err )
 485     {
 486       r = "ImageReader: " + std::string( err.GetDescription( ) );
 487       cpPlugins::Interface::Image* out =
 488         this->_Output< cpPlugins::Interface::Image >( 0 );
 489       if( out != NULL )
 490         out->SetITKImage< _I >( NULL );
 491       else
 492         r = "ImageReader: output not correctly created.";
 493
 494     } // yrt
 495   }
 496   else
 497     r = "ImageReader: No image files given";
 498   return( r );
 499 }
 500
 501 // eof - $RCSfile$