lib/cpPlugins/Plugins/IO/ImageReader.cxx

   1 #include "ImageReader.h"
   2 #include <cpPlugins/Interface/Image.h>
   3
   4 #include <itkImageFileReader.h>
   5 #include <itkImageSeriesReader.h>
   6
   7 #ifdef cpPlugins_Interface_QT4
   8 #include <QFileDialog>
   9 #endif // cpPlugins_Interface_QT4
  10
  11 // -------------------------------------------------------------------------
  12 bool cpPlugins::IO::ImageReader::
  13 ExecConfigurationDialog( QWidget* parent )
  14 {
  15   bool r = false;
  16
  17 #ifdef cpPlugins_Interface_QT4
  18
  19   QStringList filters;
  20   filters
  21     << "Image files (*.bmp *.png *.jpg *.jpeg *.dcm *.mhd *.nhdr *.nrrd *.tiff)"
  22     << "Any files (*)";
  23
  24   std::vector< std::string > names;
  25   this->m_Parameters->GetStringList( names, "FileNames" );
  26   std::string name = ( names.size( ) > 0 )? names[ 0 ]: ".";
  27
  28   // Show dialog and check if it was accepted
  29   QFileDialog dialog( parent );
  30   dialog.setFileMode( QFileDialog::ExistingFiles );
  31   dialog.setDirectory( QFileDialog::tr( name.c_str( ) ) );
  32   dialog.setNameFilters( filters );
  33   if( dialog.exec( ) )
  34   {
  35     QStringList names = dialog.selectedFiles( );
  36     QStringList::const_iterator qIt = names.begin( );
  37     for( ; qIt != names.end( ); ++qIt )
  38       this->m_Parameters->AddToStringList(
  39         "FileNames", qIt->toStdString( )
  40         );
  41     this->m_Parameters->SetBool( "VectorType", false );
  42     r = true;
  43
  44   } // fi
  45
  46 #endif // cpPlugins_Interface_QT4
  47
  48   return( r );
  49 }
  50
  51 // -------------------------------------------------------------------------
  52 cpPlugins::IO::ImageReader::
  53 ImageReader( )
  54   : Superclass( )
  55 {
  56   this->_MakeOutput< cpPlugins::Interface::Image >( "Output" );
  57
  58   this->m_Parameters->ConfigureAsStringList( "FileNames" );
  59   this->m_Parameters->ConfigureAsBool( "VectorType", false );
  60 }
  61
  62 // -------------------------------------------------------------------------
  63 cpPlugins::IO::ImageReader::
  64 ~ImageReader( )
  65 {
  66 }
  67
  68 // -------------------------------------------------------------------------
  69 std::string cpPlugins::IO::ImageReader::
  70 _GenerateData( )
  71 {
  72   // Get filenames
  73   TStringList names;
  74   this->m_Parameters->GetStringList( names, "FileNames" );
  75
  76   std::string r = "";
  77   if( names.size( ) >= 1 )
  78   {
  79     // Guess image properties
  80     itk::ImageIOBase::Pointer io =
  81       itk::ImageIOFactory::CreateImageIO(
  82         names[ 0 ].c_str( ),
  83         itk::ImageIOFactory::ReadMode
  84         );
  85     if( io.IsNotNull( ) )
  86     {
  87       io->SetFileName( names[ 0 ] );
  88       io->ReadImageInformation( );
  89       if( names.size( ) >= 1 )
  90       {
  91         switch( io->GetNumberOfDimensions( ) )
  92         {
  93         case 2: r = this->_GD0< 2 >( io, names ); break;
  94         case 3: r = this->_GD0< 3 >( io, names ); break;
  95         case 4: r = this->_GD0< 4 >( io, names ); break;
  96         default:
  97           r = "ImageReader: Image dimension not supported.";
  98           break;
  99         } // hctiws
 100
 101       } // fi
 102     }
 103     else
 104       r = "ImageReader: Could not CreateImageIO for \"" + names[ 0 ] + "\"";
 105   }
 106   else
 107     r = "No image files given";
 108   return( r );
 109 }
 110
 111 // -------------------------------------------------------------------------
 112 template< unsigned int D >
 113 std::string cpPlugins::IO::ImageReader::
 114 _GD0( itk::ImageIOBase* io, const TStringList& names )
 115 {
 116   itk::ImageIOBase::IOComponentType ct = io->GetComponentType( );
 117   itk::ImageIOBase::IOPixelType pt = io->GetPixelType( );
 118   std::string r = "";
 119
 120   if( pt == itk::ImageIOBase::SCALAR )
 121   {
 122     switch( ct )
 123     {
 124     case itk::ImageIOBase::UCHAR:
 125       r = this->_GD1< unsigned char, D >( names );
 126       break;
 127     case itk::ImageIOBase::CHAR:
 128       r = this->_GD1< char, D >( names );
 129       break;
 130     case itk::ImageIOBase::USHORT:
 131       r = this->_GD1< unsigned short, D >( names );
 132       break;
 133     case itk::ImageIOBase::SHORT:
 134       r = this->_GD1< short, D >( names );
 135       break;
 136     case itk::ImageIOBase::UINT:
 137       r = this->_GD1< unsigned int, D >( names );
 138       break;
 139     case itk::ImageIOBase::INT:
 140       r = this->_GD1< int, D >( names );
 141       break;
 142     case itk::ImageIOBase::ULONG:
 143       r = this->_GD1< unsigned long, D >( names );
 144       break;
 145     case itk::ImageIOBase::LONG:
 146       r = this->_GD1< long, D >( names );
 147       break;
 148     case itk::ImageIOBase::FLOAT:
 149       r = this->_GD1< float, D >( names );
 150       break;
 151     case itk::ImageIOBase::DOUBLE:
 152       r = this->_GD1< double, D >( names );
 153       break;
 154     default:
 155       r = "ImageReader: Scalar pixel type not supported.";
 156       break;
 157     } // hctiws
 158   }
 159   else if( pt == itk::ImageIOBase::RGB )
 160   {
 161     switch( ct )
 162     {
 163     case itk::ImageIOBase::UCHAR:
 164       r = this->_GD1< itk::RGBPixel< unsigned char >, D >( names );
 165       break;
 166     case itk::ImageIOBase::CHAR:
 167       r = this->_GD1< itk::RGBPixel< char >, D >( names );
 168       break;
 169     case itk::ImageIOBase::USHORT:
 170       r = this->_GD1< itk::RGBPixel< unsigned short >, D >( names );
 171       break;
 172     case itk::ImageIOBase::SHORT:
 173       r = this->_GD1< itk::RGBPixel< short >, D >( names );
 174       break;
 175     case itk::ImageIOBase::UINT:
 176       r = this->_GD1< itk::RGBPixel< unsigned int >, D >( names );
 177       break;
 178     case itk::ImageIOBase::INT:
 179       r = this->_GD1< itk::RGBPixel< int >, D >( names );
 180       break;
 181     case itk::ImageIOBase::ULONG:
 182       r = this->_GD1< itk::RGBPixel< unsigned long >, D >( names );
 183       break;
 184     case itk::ImageIOBase::LONG:
 185       r = this->_GD1< itk::RGBPixel< long >, D >( names );
 186       break;
 187     case itk::ImageIOBase::FLOAT:
 188       r = this->_GD1< itk::RGBPixel< float >, D >( names );
 189       break;
 190     case itk::ImageIOBase::DOUBLE:
 191       r = this->_GD1< itk::RGBPixel< double >, D >( names );
 192       break;
 193     default:
 194       r = "ImageReader: RGB pixel type not supported.";
 195       break;
 196     } // hctiws
 197   }
 198   else if( pt == itk::ImageIOBase::RGBA )
 199   {
 200     switch( ct )
 201     {
 202     case itk::ImageIOBase::UCHAR:
 203       r = this->_GD1< itk::RGBAPixel< unsigned char >, D >( names );
 204       break;
 205     case itk::ImageIOBase::CHAR:
 206       r = this->_GD1< itk::RGBAPixel< char >, D >( names );
 207       break;
 208     case itk::ImageIOBase::USHORT:
 209       r = this->_GD1< itk::RGBAPixel< unsigned short >, D >( names );
 210       break;
 211     case itk::ImageIOBase::SHORT:
 212       r = this->_GD1< itk::RGBAPixel< short >, D >( names );
 213       break;
 214     case itk::ImageIOBase::UINT:
 215       r = this->_GD1< itk::RGBAPixel< unsigned int >, D >( names );
 216       break;
 217     case itk::ImageIOBase::INT:
 218       r = this->_GD1< itk::RGBAPixel< int >, D >( names );
 219       break;
 220     case itk::ImageIOBase::ULONG:
 221       r = this->_GD1< itk::RGBAPixel< unsigned long >, D >( names );
 222       break;
 223     case itk::ImageIOBase::LONG:
 224       r = this->_GD1< itk::RGBAPixel< long >, D >( names );
 225       break;
 226     case itk::ImageIOBase::FLOAT:
 227       r = this->_GD1< itk::RGBAPixel< float >, D >( names );
 228       break;
 229     case itk::ImageIOBase::DOUBLE:
 230       r = this->_GD1< itk::RGBAPixel< double >, D >( names );
 231       break;
 232     default:
 233       r = "ImageReader: RGBA pixel type not supported.";
 234       break;
 235     } // hctiws
 236   }
 237   else if( pt == itk::ImageIOBase::VECTOR )
 238   {
 239     switch( ct )
 240     {
 241     case itk::ImageIOBase::FLOAT:
 242       r = this->_GD1< itk::Vector< float, D >, D >( names );
 243       break;
 244     case itk::ImageIOBase::DOUBLE:
 245       r = this->_GD1< itk::Vector< double, D >, D >( names );
 246       break;
 247     default:
 248       r = "ImageReader: Vector type not supported.";
 249       break;
 250     } // hctiws
 251   }
 252   else if( pt == itk::ImageIOBase::POINT )
 253   {
 254     switch( ct )
 255     {
 256     case itk::ImageIOBase::FLOAT:
 257       r = this->_GD1< itk::Point< float, D >, D >( names );
 258       break;
 259     case itk::ImageIOBase::DOUBLE:
 260       r = this->_GD1< itk::Point< double, D >, D >( names );
 261       break;
 262     default:
 263       r = "ImageReader: Point type not supported.";
 264       break;
 265     } // hctiws
 266   }
 267   else if( pt == itk::ImageIOBase::COVARIANTVECTOR )
 268   {
 269     switch( ct )
 270     {
 271     case itk::ImageIOBase::FLOAT:
 272       r = this->_GD1< itk::CovariantVector< float, D >, D >( names );
 273       break;
 274     case itk::ImageIOBase::DOUBLE:
 275       r = this->_GD1< itk::CovariantVector< double, D >, D >( names );
 276       break;
 277     default:
 278       r = "ImageReader: CovariantVector type not supported.";
 279       break;
 280     } // hctiws
 281   }
 282   else if( pt == itk::ImageIOBase::SYMMETRICSECONDRANKTENSOR )
 283   {
 284     switch( ct )
 285     {
 286     case itk::ImageIOBase::FLOAT:
 287       r =
 288         this->_GD1< itk::SymmetricSecondRankTensor< float, D >, D >(
 289           names
 290           );
 291       break;
 292     case itk::ImageIOBase::DOUBLE:
 293       r =
 294         this->_GD1< itk::SymmetricSecondRankTensor< double, D >, D >(
 295           names
 296           );
 297       break;
 298     default:
 299       r = "ImageReader: Vector type not supported.";
 300       break;
 301     } // hctiws
 302   }
 303   else if( pt == itk::ImageIOBase::DIFFUSIONTENSOR3D )
 304   {
 305     switch( ct )
 306     {
 307     case itk::ImageIOBase::FLOAT:
 308       r = this->_GD1< itk::DiffusionTensor3D< float >, D >( names );
 309       break;
 310     case itk::ImageIOBase::DOUBLE:
 311       r = this->_GD1< itk::DiffusionTensor3D< double >, D >( names );
 312       break;
 313     default:
 314       r = "ImageReader: Diffusion tensor type not supported.";
 315       break;
 316     } // hctiws
 317   }
 318   else if( pt == itk::ImageIOBase::COMPLEX )
 319   {
 320     switch( ct )
 321     {
 322     case itk::ImageIOBase::FLOAT:
 323       r = this->_GD1< std::complex< float >, D >( names );
 324       break;
 325     case itk::ImageIOBase::DOUBLE:
 326       r = this->_GD1< std::complex< double >, D >( names );
 327       break;
 328     default:
 329       r = "ImageReader: Complex type not supported.";
 330       break;
 331     } // hctiws
 332   }
 333   else if( pt == itk::ImageIOBase::OFFSET )
 334     r = this->_GD1< itk::Offset< D >, D >( names );
 335   else
 336     r = "ImageReader: Image pixel type not yet supported.";
 337   /* TODO
 338      itk::ImageIOBase::FIXEDARRAY
 339      itk::ImageIOBase::MATRIX
 340   */
 341   return( r );
 342 }
 343
 344 // -------------------------------------------------------------------------
 345 template< class P, unsigned int D >
 346 std::string cpPlugins::IO::ImageReader::
 347 _GD1( const TStringList& names )
 348 {
 349   if( this->m_Parameters->GetBool( "VectorType" ) )
 350     return( this->_RealGD< itk::VectorImage< P, D > >( names ) );
 351   else
 352     return( this->_RealGD< itk::Image< P, D > >( names ) );
 353 }
 354
 355 // -------------------------------------------------------------------------
 356 template< class I >
 357 std::string cpPlugins::IO::ImageReader::
 358 _RealGD( const TStringList& names )
 359 {
 360   cpPlugins::Interface::Image* out =
 361     this->GetOutput< cpPlugins::Interface::Image >( "Output" );
 362   if( out == NULL )
 363     return( "ImageReader: No output object properly created." );
 364
 365   std::string r = "";
 366   if( names.size( ) == 1 )
 367   {
 368     // Read single image
 369     typedef itk::ImageFileReader< I > _SR;
 370     _SR* reader = this->_CreateITK< _SR >( );
 371     reader->SetFileName( names[ 0 ] );
 372     try
 373     {
 374       reader->Update( );
 375       out->SetITK< I >( reader->GetOutput( ) );
 376       out->SetName( names[ 0 ] );
 377     }
 378     catch( itk::ExceptionObject& err )
 379     {
 380       r = "ImageReader: " + std::string( err.GetDescription( ) );
 381       out->SetITK< I >( NULL );
 382       out->SetName( "" );
 383
 384     } // yrt
 385   }
 386   else if( names.size( ) > 1 )
 387   {
 388     // Read image series
 389     typedef itk::ImageSeriesReader< I > _MR;
 390     _MR* reader = this->_CreateITK< _MR >( );
 391     for( unsigned int i = 0; i < names.size( ); ++i )
 392       reader->AddFileName( names[ i ] );
 393     try
 394     {
 395       reader->Update( );
 396       out->SetITK< I >( reader->GetOutput( ) );
 397       out->SetName( names[ 0 ] );
 398     }
 399     catch( itk::ExceptionObject& err )
 400     {
 401       r = "ImageReader: " + std::string( err.GetDescription( ) );
 402       out->SetITK< I >( NULL );
 403       out->SetName( "" );
 404
 405     } // yrt
 406   }
 407   else
 408     r = "ImageReader: No image files given";
 409   return( r );
 410 }
 411
 412 // eof - $RCSfile$