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