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