lib/cpPlugins/Plugins/IO/ImageReader.cxx

   1 #include "ImageReader.h"
   2 #include <cpPlugins/Interface/Image.h>
   3
   4 #include <set>
   5
   6 #include <itkImageFileReader.h>
   7 #include <itkImageSeriesReader.h>
   8
   9 #ifdef cpPlugins_Interface_QT4
  10 #include <QFileDialog>
  11 #endif // cpPlugins_Interface_QT4
  12
  13 // -------------------------------------------------------------------------
  14 bool cpPlugins::IO::ImageReader::
  15 ExecConfigurationDialog( QWidget* parent )
  16 {
  17   bool r = false;
  18
  19 #ifdef cpPlugins_Interface_QT4
  20
  21   // Show dialog and check if it was accepted
  22   QFileDialog dialog( parent );
  23   dialog.setFileMode( QFileDialog::ExistingFiles );
  24   dialog.setDirectory( QFileDialog::tr( "." ) );
  25   dialog.setNameFilter( QFileDialog::tr( "All files (*)" ) );
  26   if( dialog.exec( ) )
  27   {
  28     this->m_Parameters = this->m_DefaultParameters;
  29     QStringList names = dialog.selectedFiles( );
  30     QStringList::const_iterator qIt = names.begin( );
  31     for( ; qIt != names.end( ); ++qIt )
  32       this->m_Parameters.AddValueToStringList(
  33         "FileNames", qIt->toStdString( )
  34         );
  35     this->m_Parameters.SetValueAsBool( "VectorType", false );
  36     r = true;
  37
  38   } // fi
  39
  40 #endif // cpPlugins_Interface_QT4
  41
  42   return( r );
  43 }
  44
  45 // -------------------------------------------------------------------------
  46 cpPlugins::IO::ImageReader::
  47 ImageReader( )
  48   : Superclass( )
  49 {
  50   this->m_ClassName = "cpPlugins::IO::ImageReader";
  51   this->m_ClassCategory = "ImageReader";
  52
  53   this->SetNumberOfOutputs( 1 );
  54   this->_MakeOutput< cpPlugins::Interface::Image >( 0 );
  55
  56   using namespace cpPlugins::Interface;
  57   this->m_DefaultParameters.Configure( Parameters::StringList, "FileNames" );
  58   this->m_DefaultParameters.Configure( Parameters::Bool, "VectorType" );
  59   this->m_DefaultParameters.SetValueAsBool( "VectorType", false );
  60   this->m_Parameters = this->m_DefaultParameters;
  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.GetValueAsStringList( 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.GetValueAsBool( "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 >( 0 );
 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 =
 372       dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
 373     if( reader == NULL )
 374     {
 375       this->m_RealProcessObject = _SR::New( );
 376       reader =
 377         dynamic_cast< _SR* >( this->m_RealProcessObject.GetPointer( ) );
 378
 379     } // fi
 380     reader->SetFileName( names[ 0 ] );
 381     try
 382     {
 383       reader->Update( );
 384       out->SetITKImage< I >( reader->GetOutput( ) );
 385     }
 386     catch( itk::ExceptionObject& err )
 387     {
 388       r = "ImageReader: " + std::string( err.GetDescription( ) );
 389       out->SetITKImage< I >( NULL );
 390
 391     } // yrt
 392   }
 393   else if( names.size( ) > 1 )
 394   {
 395     // Read image series
 396     std::set< std::string > ordered_names;
 397     for( unsigned int i = 0; i < names.size( ); ++i )
 398       ordered_names.insert( names[ i ] );
 399
 400     typedef itk::ImageSeriesReader< I > _MR;
 401     _MR* reader =
 402       dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
 403     if( reader == NULL )
 404     {
 405       this->m_RealProcessObject = _MR::New( );
 406       reader =
 407         dynamic_cast< _MR* >( this->m_RealProcessObject.GetPointer( ) );
 408
 409     } // fi
 410     std::set< std::string >::const_iterator fnIt = ordered_names.begin( );
 411     for( ; fnIt != ordered_names.end( ); ++fnIt )
 412     {
 413       reader->AddFileName( *fnIt );
 414     }
 415     try
 416     {
 417       reader->Update( );
 418       out->SetITKImage< I >( reader->GetOutput( ) );
 419     }
 420     catch( itk::ExceptionObject& err )
 421     {
 422       r = "ImageReader: " + std::string( err.GetDescription( ) );
 423       out->SetITKImage< I >( NULL );
 424
 425     } // yrt
 426   }
 427   else
 428     r = "ImageReader: No image files given";
 429   return( r );
 430 }
 431
 432 // eof - $RCSfile$