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