lib/cpPlugins/Plugins/ImageReader.cxx

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