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