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