f.r.e.e. - Flexible Registration and Evaluation Engine: freImageIO.txx Source File

00001 /*=========================================================================
00002 
00003   Program:   F.R.E.E. - flexible registration evaluation engine
00004   Version:   v.1.0.0
00005   Date:      $Date: 2006/09/01 12:00:00 $
00006   Module:    $RCSfile: freImageIO.txx,v $
00007   Language:  C++
00008 
00009 
00010 
00011   Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
00012   Institute for Medical Biometry and Informatics, University of Heidelberg,
00013   Germany). All rights reserved.
00014   See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
00015   for details.
00016 
00017      This software is distributed WITHOUT ANY WARRANTY; without even 
00018      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00019      PURPOSE.  See the above copyright notices for more information.
00020 
00021 =========================================================================*/
00022 #ifndef __freImageIO_txx
00023 #define __freImageIO_txx
00024 
00025 #include "freImageIO.h"
00026 
00027 #include "freExceptions.h"
00028 #include "freFileDispatch.h"
00029 
00030 namespace FREE
00031 {
00032 
00036 
00037 
00038 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00039 typename ImageWriter<TInputPixel,TOutputPixel,iDimension>::InputImageType*
00040 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00041 ConvertImageToIsoSpacing()
00042 {
00043         itk::FixedArray< double, iDimension> scales;
00044         const typename InputImageType::SpacingType& rSpacing = m_Image->GetSpacing();
00045         typename InputImageType::SpacingType newSpacing;
00046         double dCheck = 1.0;
00047 
00048         itk::Size<iDimension> newSize;
00049         const itk::Size<iDimension>& oldSize = m_Image->GetLargestPossibleRegion().GetSize();
00050 
00051         for (int iIndex=0; iIndex< iDimension; iIndex ++)
00052         {
00053                 newSpacing[iIndex] = 1.0;
00054                 if (rSpacing[iIndex]!=0) scales[iIndex] = 1/(rSpacing[iIndex]);
00055 
00056                 dCheck = dCheck+rSpacing[iIndex]-1.0;
00057                 newSize[iIndex] = static_cast<unsigned long>(floor(oldSize[iIndex]*rSpacing[iIndex]));
00058         };
00059 
00060         if (dCheck!=0.0)
00061         {
00062                 //only if at least one spacing is not 1 the image must be resampled.
00063                 typedef itk::ResampleImageFilter< InputImageType, InputImageType > ResampleType;
00064                 typedef itk::ScaleTransform< double, iDimension > ScaleType;
00065                 typename ResampleType::Pointer resampler = ResampleType::New();
00066                 typename InputImageType::Pointer imageTemp = InputImageType::New();
00067 
00068                 typename ScaleType::Pointer scaler = ScaleType::New();
00069 
00070                 scaler->SetScale(scales);
00071 
00072                 resampler->SetTransform(scaler);
00073                 resampler->SetSize(newSize);
00074                 resampler->SetOutputOrigin(m_Image->GetOrigin());
00075                 resampler->SetOutputSpacing(newSpacing);
00076                 resampler->SetDefaultPixelValue( 0 );
00077                 resampler->SetInput(m_Image);
00078                 imageTemp = resampler->GetOutput();
00079                 resampler->Update();
00080                 return imageTemp;
00081         };
00082 
00083         return m_Image;
00084 };
00085 
00086 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00087 void
00088 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00089 Save2D()
00090 {
00091         typedef itk::ImageFileWriter< OutputImageType  > ImageWriterType;
00092         typedef itk::RescaleIntensityImageFilter< InputImageType, InputImageType > FilterType;
00093         typedef itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType;              
00094 
00095         typename CastFilterType::Pointer  imageCaster =  CastFilterType::New();
00096         typename ImageWriterType::Pointer  imageWriter  = ImageWriterType::New();
00097         typename FilterType::Pointer rescaleFilter = FilterType::New();
00098 
00099         rescaleFilter->SetOutputMinimum( m_dRescaleMin );
00100         rescaleFilter->SetOutputMaximum( m_dRescaleMax );
00101 
00102         if (m_bRescaleImage)
00103         {
00104                 if (m_bForceIsoVoxel)
00105                 {
00106                         rescaleFilter->SetInput(ConvertImageToIsoSpacing());
00107                 }
00108                 else
00109                 {
00110                         rescaleFilter->SetInput(m_Image);
00111                 }
00112                 imageCaster->SetInput(rescaleFilter->GetOutput());
00113         }
00114         else
00115         {
00116                 if (m_bForceIsoVoxel)
00117                 {
00118                         imageCaster->SetInput(ConvertImageToIsoSpacing());
00119                 }
00120                 else
00121                 {
00122                         imageCaster->SetInput(m_Image);
00123                 }
00124         }
00125 
00126 
00127         imageWriter->SetFileName(m_FileName.c_str());
00128         imageWriter->SetInput(imageCaster->GetOutput());
00129 
00130         try
00131         {
00132                 imageWriter->Update();
00133         }
00134         catchAllNPassMacro("Error while saving image with itk image io.");
00135 };
00136 
00137 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00138 void
00139 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00140 Save3D()
00141 {
00142   FileDispatch dispatch(m_FileName);
00143         std::string  sTemp= dispatch.GetExtension();
00144         //Converts to lowercase, because itk:analyzeIO is bugged and only checks for lower case
00145         for (std::string::iterator spos = sTemp.begin(); spos!=sTemp.end(); spos++){(*spos) = std::tolower((*spos),std::locale("english"));}
00146 
00147         if ((sTemp==".png")||(sTemp==".bmp")||(sTemp==".jpg")||(sTemp==".tif"))
00148         {
00149                 /* //error in the itkImageSeriesWriter
00150                 typedef itk::ImageSeriesWriter< OutputImageType  > SeriesWriterType;
00151                 typedef itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType;              
00152 
00153                 SeriesWriterType::Pointer  seriesWriter  = SeriesWriterType::New();
00154                 CastFilterType::Pointer  imageCaster =  CastFilterType::New();
00155                 FileNumericIteratorBase::Pointer fileIterator = FileNumericIteratorBase::New();
00156 
00157                 fileIterator->SetSeriesFormat(m_FileName);
00158                 fileIterator->WriteModeOn();
00159                 seriesWriter->SetFileIterator(fileIterator);
00160 
00161                 if (m_bForceIsoVoxel) imageCaster->SetInput(ConvertImageToIsoSpacing());
00162                 else imageCaster->SetInput(m_Image);
00163 
00164                 seriesWriter->SetInput(imageCaster->GetOutput());
00165 
00166                 seriesWriter->Update();*/
00167         }
00168   else
00169         {
00170                 //others (e.g. Analyze, MetaImage) uses the direct itk IO like 2D images
00171                 Save2D();
00172         }
00173 };
00174 
00175 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00176 const std::string
00177 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00178 GetFileName() const
00179 {
00180         return m_FileName; 
00181 };
00182 
00183 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00184 void
00185 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00186 SetFileName(const std::string  sFileName)
00187 {
00188   m_FileName = sFileName;
00189 }
00190 
00191 
00192 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00193 const bool
00194 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00195 GetForceIsoVoxel() const
00196 {
00197         return m_bForceIsoVoxel;
00198 };
00199 
00200 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00201 void
00202 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00203 SetForceIsoVoxel(const bool bForceIsoVoxel)
00204 {
00205   m_bForceIsoVoxel = bForceIsoVoxel;
00206 };
00207 
00208 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00209 const double
00210 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00211 GetRescaleMinimum() const 
00212 {
00213         return m_dRescaleMin; 
00214 };
00215 
00216 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00217 void
00218 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00219 SetRescaleMinimum(const double dRescaleMin)
00220 {
00221   m_dRescaleMin = dRescaleMin;
00222 };
00223 
00224 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00225 const double
00226 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00227 GetRescaleMaximum() const 
00228 {
00229         return m_dRescaleMax; 
00230 };
00231 
00232 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00233 void
00234 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00235 SetRescaleMaximum(const double dRescaleMax)
00236 {
00237   m_dRescaleMax = dRescaleMax;
00238 };
00239   
00240 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00241 const bool
00242 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00243 GetRescaleImage() const 
00244 {
00245         return m_bRescaleImage;
00246 };
00247 
00248 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00249 void
00250 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00251 SetRescaleImage(const bool bRescaleImage)
00252 {
00253   m_bRescaleImage = bRescaleImage;
00254 };
00255 
00258 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00259 void
00260 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00261 SetInput (InputImageType* pImage)
00262 {
00263         m_Image = pImage;
00264 };
00265 
00267 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00268 void
00269 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00270 Update ()
00271 {
00272         if (!m_Image) throwExceptionMacro("No image specified to save.");
00273         if (m_FileName == "") throwExceptionMacro("No filename specified for file to save.");
00274 
00275         switch (OutputImageType::GetImageDimension())
00276         {
00277                 case 2: Save2D(); break;
00278                 case 3: Save3D(); break;
00279                 default: throwExceptionMacro("Image writer only accepts 2 or 3 dimensional images.")
00280         };
00281 };
00282 
00283 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00284 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00285 ImageWriter()
00286 {
00287         m_FileName = "";
00288         m_Image = NULL;
00289         m_bForceIsoVoxel = false;
00290         m_bRescaleImage = false;
00291         m_dRescaleMax = 255;
00292         m_dRescaleMin = 0;
00293 };
00294 
00295 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00296 ImageWriter<TInputPixel,TOutputPixel,iDimension>::
00297 ~ImageWriter() 
00298 {
00299 };
00300 
00304 
00305 
00306 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00307 void
00308 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00309 ConvertImageToIsoSpacing()
00310 {
00311         itk::FixedArray< double, iDimension> scales;
00312         typedef typename OutputImageType::SpacingType SpacingType;
00313         const SpacingType& rSpacing = m_Image->GetSpacing();
00314         SpacingType newSpacing;
00315         double dCheck = 1.0;
00316 
00317         itk::Size<iDimension> newSize;
00318         const itk::Size<iDimension>& oldSize = m_Image->GetLargestPossibleRegion().GetSize();
00319 
00320         for (int iIndex=0; iIndex< iDimension; iIndex ++)
00321         {
00322                 newSpacing[iIndex] = 1.0;
00323                 scales[iIndex] = 1;
00324 
00325                 dCheck = dCheck+(rSpacing[iIndex] - 1.0);
00326                 newSize[iIndex] = static_cast<unsigned long>(floor(oldSize[iIndex]*(rSpacing[iIndex])));
00327         };
00328 
00329         if (dCheck!=0.0)
00330         {
00331                 //only if at least one spacing is not 1 the image must be resampled.
00332                 typedef itk::ResampleImageFilter< OutputImageType, OutputImageType > ResampleType;
00333                 typedef itk::ScaleTransform< double, iDimension > ScaleType;
00334                 typename ResampleType::Pointer resampler = ResampleType::New();
00335                 typename OutputImageType::Pointer m_ImageTemp = OutputImageType::New();
00336 
00337                 typename ScaleType::Pointer scaler = ScaleType::New();
00338 
00339                 scaler->SetScale(scales);
00340 
00341                 resampler->SetTransform(scaler);
00342                 resampler->SetSize(newSize);
00343                 resampler->SetOutputOrigin(m_Image->GetOrigin());
00344                 resampler->SetOutputSpacing(newSpacing);
00345                 resampler->SetDefaultPixelValue( 0 );
00346                 resampler->SetInput(m_Image);
00347                 m_ImageTemp = resampler->GetOutput();
00348                 resampler->Update();
00349                 m_Image = m_ImageTemp;
00350         };
00351 
00352 };
00353 
00354 
00355 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00356 void
00357 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00358 Load2D()
00359 {
00360         typedef itk::ImageFileReader< InputImageType  > ImageReaderType;
00361         typedef itk::RescaleIntensityImageFilter< InputImageType, InputImageType > FilterType;
00362         typedef itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType;              
00363 
00364         typename CastFilterType::Pointer  imageCaster =  CastFilterType::New();
00365         typename ImageReaderType::Pointer imageReader  = ImageReaderType::New();
00366         typename FilterType::Pointer rescaleFilter = FilterType::New();
00367 
00368         rescaleFilter->SetOutputMinimum( static_cast<TInputPixel>(m_dRescaleMin) );
00369         rescaleFilter->SetOutputMaximum( static_cast<TInputPixel>(m_dRescaleMax) );
00370 
00371     imageReader->SetFileName(m_FileName.c_str());
00372         rescaleFilter->SetInput(imageReader->GetOutput());
00373 
00374         if (m_bRescaleImage) imageCaster->SetInput(rescaleFilter->GetOutput());
00375         else imageCaster->SetInput(imageReader->GetOutput());
00376 
00377     m_Image = imageCaster->GetOutput();
00378 
00379         try
00380         {
00381           imageCaster->Update();
00382         }
00383   catchAllNPassMacro("Error while loading image with itk image io.");
00384 
00385         if (m_bForceIsoVoxel)
00386         {
00387           this->ConvertImageToIsoSpacing();
00388         }
00389 
00390         m_bUpToDate = true;
00391 };
00392 
00393 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00394 void
00395 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00396 Load3D()
00397 {
00398   FileDispatch dispatch(m_FileName);
00399 
00400   std::string   sTemp = dispatch.GetExtension();
00401         std::string  sDir = dispatch.GetPath();
00402         //Convert to lowercase, because itk:analyzeIO is bugged and only check for lower case
00403         for (std::string::iterator spos = sTemp.begin(); spos!=sTemp.end(); spos++){(*spos) = std::tolower((*spos),std::locale("english"));}
00404 
00405         typedef itk::RescaleIntensityImageFilter< InputImageType, InputImageType > FilterType;
00406         typedef itk::CastImageFilter< InputImageType, OutputImageType > CastFilterType;              
00407         typename CastFilterType::Pointer  imageCaster =  CastFilterType::New();
00408         typename FilterType::Pointer rescaleFilter = FilterType::New();
00409 
00410         rescaleFilter->SetOutputMinimum( static_cast<TInputPixel>(m_dRescaleMin) );
00411         rescaleFilter->SetOutputMaximum( static_cast<TInputPixel>(m_dRescaleMax) );
00412 
00413         if ((sTemp==".png")||(sTemp==".bmp")||(sTemp==".jpg")||(sTemp==".tif"))
00414         {
00415                 //Normal series image reader
00416                 typedef itk::ImageSeriesReader< InputImageType  > SeriesReaderType;
00417                 typedef itk::NumericSeriesFileNames NamesType;
00418 
00419                 typename SeriesReaderType::Pointer  seriesReader  = SeriesReaderType::New();
00420                 NamesType::Pointer names = NamesType::New();
00421 
00422                 names->SetStartIndex(1);
00423                 names->SetEndIndex(m_iUpperSeriesLimit);
00424                 names->SetSeriesFormat(m_FileName.c_str());
00425 
00426                 seriesReader->SetFileNames(names->GetFileNames());
00427 
00428                 rescaleFilter->SetInput(seriesReader->GetOutput());
00429                 if (m_bRescaleImage) imageCaster->SetInput(rescaleFilter->GetOutput());
00430                 else imageCaster->SetInput(seriesReader->GetOutput());
00431 
00432                 m_Image = imageCaster->GetOutput();
00433 
00434                 try
00435                 {
00436                         imageCaster->Update();
00437                 }
00438     catchAllNPassMacro("Error while loading image with itk image io.");
00439         }
00440         else if (sTemp==".dcm")
00441         {
00442                 //its a DICOM file saved as separated slices
00443                 typedef itk::ImageSeriesReader< InputImageType  > SeriesReaderType;
00444                 typedef itk::DICOMSeriesFileNames DICOMNamesType;
00445 
00446                 typename SeriesReaderType::Pointer  seriesReader  = SeriesReaderType::New();
00447                 DICOMNamesType::Pointer names = DICOMNamesType::New();
00448 
00449                 names->SetDirectory(sDir);
00450                 names->SetFileNameSortingOrderToSortByImagePositionPatient();
00451 
00452                 seriesReader->SetFileNames(names->GetFileNames());
00453 
00454                 rescaleFilter->SetInput(seriesReader->GetOutput());
00455                 if (m_bRescaleImage) imageCaster->SetInput(rescaleFilter->GetOutput());
00456                 else imageCaster->SetInput(seriesReader->GetOutput());
00457 
00458                 m_Image = imageCaster->GetOutput();
00459 
00460                 try
00461                 {
00462                         imageCaster->Update();
00463                 }
00464     catchAllNPassMacro("Error while loading image with itk image io.");
00465         }
00466         else
00467         {
00468                 //Normal image reader
00469                 typedef itk::ImageFileReader< InputImageType  > ImageReaderType;
00470 
00471                 typename ImageReaderType::Pointer  imageReader  = ImageReaderType::New();
00472 
00473                 imageReader->SetFileName(m_FileName.c_str() );
00474 
00475                 rescaleFilter->SetInput(imageReader->GetOutput());
00476                 if (m_bRescaleImage) imageCaster->SetInput(rescaleFilter->GetOutput());
00477                 else imageCaster->SetInput(imageReader->GetOutput());
00478 
00479                 m_Image = imageCaster->GetOutput();
00480                 try
00481                 {
00482                         imageCaster->Update();
00483                 }
00484     catchAllNPassMacro("Error while loading image with itk image io.");
00485         }
00486 
00487         if (m_bForceIsoVoxel)
00488         {
00489                 ConvertImageToIsoSpacing();
00490         }
00491 
00492         m_bUpToDate = true;
00493 };
00494 
00495 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00496 const std::string
00497 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00498 GetFileName() const
00499 {
00500         return m_FileName;
00501 };
00502 
00503 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00504 void
00505 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00506 SetFileName(const std::string  sFileName)
00507 {
00508         if (sFileName!=m_FileName)
00509         {
00510           m_bUpToDate = false;
00511           m_FileName = sFileName;
00512         }
00513 }
00514 
00515 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00516 const double
00517 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00518 GetRescaleMinimum() const
00519 {
00520         return m_dRescaleMin;
00521 };
00522 
00523 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00524 void
00525 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00526 SetRescaleMinimum(const double dRescaleMin)
00527 {
00528         if (dRescaleMin!=m_dRescaleMin)
00529         {
00530           m_bUpToDate = false;
00531           m_dRescaleMin = dRescaleMin;
00532         };
00533 };
00534 
00535 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00536 const double
00537 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00538 GetRescaleMaximum() const 
00539 {
00540         return m_dRescaleMax;
00541 };
00542 
00543 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00544 void
00545 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00546 SetRescaleMaximum(const double dRescaleMax)
00547 {
00548         if (dRescaleMax!=m_dRescaleMax)
00549         {
00550           m_bUpToDate = false;
00551           m_dRescaleMax = dRescaleMax;
00552         };
00553 };
00554   
00555 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00556 const bool
00557 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00558 GetRescaleImage() const 
00559 {
00560         return m_bRescaleImage;
00561 };
00562 
00563 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00564 void
00565 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00566 SetRescaleImage(const bool bRescaleImage)
00567 {
00568         if (bRescaleImage!=m_bRescaleImage)
00569         {
00570           m_bUpToDate = false;
00571           m_bRescaleImage = bRescaleImage;
00572         };
00573 };
00574 
00575 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00576 const int
00577 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00578 GetUpperSeriesLimit() const
00579 {
00580         return m_iUpperSeriesLimit;
00581 };
00582 
00583 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00584 void
00585 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00586 SetUpperSeriesLimit(const int iUpperLimit)
00587 {
00588         if (iUpperLimit!=m_iUpperSeriesLimit)
00589         {
00590           m_bUpToDate = false;
00591           m_iUpperSeriesLimit = iUpperLimit;
00592         };
00593 };
00594 
00595 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00596 const bool
00597 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00598 GetForceIsoVoxel() const
00599 {
00600         return m_bForceIsoVoxel;
00601 };
00602 
00603 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00604 void
00605 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00606 SetForceIsoVoxel(const bool bForceIsoVoxel)
00607 {
00608         if (bForceIsoVoxel!=m_bForceIsoVoxel)
00609         {
00610           m_bUpToDate = false;
00611           m_bForceIsoVoxel = bForceIsoVoxel;
00612         };
00613 };
00614 
00615 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00616 typename ImageReader<TInputPixel,TOutputPixel,iDimension>::OutputImageType*
00617 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00618 GetOutput (void)
00619 {
00620         if (!m_bUpToDate)
00621         {
00622           switch (OutputImageType::GetImageDimension())
00623           {
00624                 case 2: Load2D(); break;
00625                 case 3: Load3D(); break;
00626                 default: throwExceptionMacro("Image reader only accepts 2 or 3 dimensional images.")
00627           };
00628         };
00629 
00630   return m_Image;
00631 };
00632 
00633 
00634 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00635 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00636 ImageReader()
00637 {
00638         m_FileName = "";
00639         m_bForceIsoVoxel = false;
00640         m_iUpperSeriesLimit = 255;
00641         m_bUpToDate = false;
00642         m_bRescaleImage = false;
00643         m_dRescaleMax = 255;
00644         m_dRescaleMin = 0;
00645 };
00646 
00647 template <typename TInputPixel,typename TOutputPixel, unsigned int iDimension>
00648 ImageReader<TInputPixel,TOutputPixel,iDimension>::
00649 ~ImageReader()
00650 {
00651 };
00652 
00653 } //end of namespace free
00654 #endif