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