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