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