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