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