milxFile.h

/*=========================================================================
  The Software is copyright (c) Commonwealth Scientific and Industrial Research Organisation (CSIRO)
  ABN 41 687 119 230.
  All rights reserved.

  Licensed under the CSIRO BSD 3-Clause License
  You may not use this file except in compliance with the License.
  You may obtain a copy of the License in the file LICENSE.md or at

  https://stash.csiro.au/projects/SMILI/repos/smili/browse/license.txt

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
=========================================================================*/
#ifndef __MILXFILE_H
#define __MILXFILE_H

//STL
#include <utility>
#include <string>
#include <algorithm>
#include <vector>
#include <sys/stat.h> //exists check
//ITK
#ifndef VTK_ONLY
  #include <itksys/SystemTools.hxx>
  #include <itkImage.h>
  #include <itkImageFileReader.h>
  #include <itkImageSeriesReader.h>
  #include <itkImageFileWriter.h>
  #include <itkTransformFileReader.h>
  #include <itkTransform.h>
  #include <itkTransformFactoryBase.h>
  #include <itkGDCMImageIO.h>
  #include <itkGDCMSeriesFileNames.h>
  #include <itkOrientImageFilter.h> //for dicom orientation
  #include <itkExtractImageFilter.h>
  #if (ITK_VERSION_MAJOR > 3)
    #include <itkComposeImageFilter.h>
  #endif
#endif
//VTK
#ifndef ITK_ONLY
  #include <vtkSmartPointer.h>
  #include <vtkCommand.h>
  #include <vtkMatrix4x4.h>
  #include <vtkImageData.h>
  #include <vtkImageFlip.h>
  #include <vtkPolyData.h>
  #include <vtkPolyDataCollection.h>
  #include <vtkTransformCollection.h>
  #include <vtkTable.h>
  #include <vtkCamera.h>
  #include <vtkXMLImageDataReader.h>
  #include <vtkXMLImageDataWriter.h>
  //MILX
  #ifndef VTK_ONLY
    #include "itkImageToVTKImageFilter.h"
    #include "itkVTKImageToImageFilter.h"
  #endif
#endif
//SMILI
#include <milxGlobal.h>

namespace milx
{

//template<class Type = float>
class SMILI_EXPORT File
{
public:
  File() {};
  virtual ~File() {};

public:
  //Images
#ifndef VTK_ONLY

  static bool CanReadImage(const std::string filename);
  static bool ReadImageInformation(const std::string filename, std::string &pixeltype, std::string &componentType, size_t &dimensions);
  static std::vector<std::string> GetSupportedImageFileExtensions();
  template<class TImage>
  static bool OpenImage(const std::string filename, typename itk::SmartPointer<TImage> &data);
#if (ITK_VERSION_MAJOR > 3)

  template<class TImage, size_t TDim>
  static bool OpenAsVectorImage(const std::string filename, typename itk::SmartPointer< itk::VectorImage< typename TImage::InternalPixelType, TDim> > &data);
#endif

  template<class TImage>
  static bool OpenImages(std::vector<std::string> &filenames, std::vector< typename itk::SmartPointer<TImage> > &images);
  template<class TImage>
  static bool SaveImage(const std::string filename, typename itk::SmartPointer<TImage> data, itk::ImageIOBase *io = NULL);
  template<class TImage>
  static bool SaveImages(std::vector<std::string> &filenames, const std::vector< typename itk::SmartPointer<TImage> > images);


  static std::vector<std::string> GetDICOMSeriesUIDs(const std::string directoryPath, bool recursive = false);
  static std::vector<std::string> GetDICOMSeriesFilenames(const std::string directoryPath, const std::string seriesName, bool recursive = false);
  template<class TImage>
  static bool GetDICOMData(const std::string directoryPath, typename itk::SmartPointer<TImage> &data, itk::MetaDataDictionary &dict, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive = false);
  template<class TImage>
  static bool GetDICOMMetaData(const std::string directoryPath, itk::MetaDataDictionary &dict, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive = false);
  template<class TImage>
  static bool GetDICOMTags(const std::string directoryPath, std::vector< std::pair<std::string, std::string> > &tags, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive = false);
  template<class TImage>
  static bool GetDICOMTags(const itk::MetaDataDictionary dictionary, std::vector< std::pair<std::string, std::string> > &tags);
  template<class TImage>
  static bool OpenDICOMSeries(const std::string directoryPath, typename itk::SmartPointer<TImage> &data, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive = false);
  template<class TImage>
  static bool OpenDICOMSeriesAndTags(const std::string directoryPath, typename itk::SmartPointer<TImage> &data, std::vector< std::pair<std::string, std::string> > &tags, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive = false);
#endif

#ifndef ITK_ONLY
  #ifndef VTK_ONLY

  template<class TImage>
  static bool OpenImage(const std::string filename, vtkSmartPointer<vtkImageData> &data);
  template<class TImage>
  static bool SaveImage(const std::string filename, vtkSmartPointer<vtkImageData> &data);
  #endif
#endif

#ifndef VTK_ONLY

  template<class TImage>
  inline static itk::SmartPointer<TImage> ReadImageUsingITK(const std::string filename);
  template<class TImage>
  inline static bool WriteImageUsingITK(const std::string filename, itk::SmartPointer<TImage> data);
#endif

  //Transforms
#ifndef VTK_ONLY

  template<class TType>
  static itk::SmartPointer< itk::Transform<TType> > OpenTransform(std::string filename);
#endif
#ifndef ITK_ONLY
  #ifndef VTK_ONLY

  static vtkMatrix4x4* OpenITKTransform(std::string filename);

  static vtkMatrix4x4* OpenVTKTransform(std::string filename);

  static void SaveITKTransform(std::string filename, const vtkMatrix4x4 * matrix);

  static void SaveVTKTransform(std::string filename, const vtkMatrix4x4 * matrix);

  #endif
#endif

#ifndef ITK_ONLY
  //Surfaces/Models
  static bool OpenModel(const std::string filename, vtkSmartPointer<vtkPolyData> &data);
  static bool OpenModelCollection(std::vector<std::string> filenames, vtkSmartPointer<vtkPolyDataCollection> &collection);
  static bool SaveModel(const std::string filename, vtkSmartPointer<vtkPolyData> data, const bool binary = false);
  static bool SaveModelCollection(std::vector<std::string> filenames, vtkSmartPointer<vtkPolyDataCollection> collection, const bool binary = false);
 static bool SaveTransform(const std::string filename, vtkSmartPointer<vtkTransform> data, const bool ITK = false);
  static bool SaveTransformCollection(std::vector<std::string> filenames, vtkSmartPointer<vtkTransformCollection> collection, const bool ITK = false);

  //CSV files
  static bool OpenDelimitedText(const std::string filename, vtkSmartPointer<vtkTable> &data, const std::string delimiter = ",");
  static bool SaveDelimitedText(const std::string filename, const vtkSmartPointer<vtkTable> data, const std::string delimiter = ",");

  //Camera
  static bool SaveCamera(const std::string filename, const vtkSmartPointer<vtkCamera> camera);
  static bool LoadCamera(const std::string filename, vtkSmartPointer<vtkCamera> &camera);
#endif

  static inline std::string StringToLowerCase(std::string filename)
  {
    std::transform(filename.begin(), filename.end(), filename.begin(), ::tolower);
    return filename;
  }
  static inline std::string StripFileExtension(const std::string &filename)
  {
    return filename.substr(0, filename.find_last_of("."));
  }
  static inline std::string ExtractFilename(const std::string &filename, char delimiter = '/')
  {
    return filename.substr( filename.find_last_of( delimiter ) + 1 );
  }
  static inline std::string ExtractPath(const std::string &filename, char delimiter = '/')
  {
    return filename.substr( 0, filename.find_last_of( delimiter ) + 1 );
  }
  static inline std::string GetBaseName(const std::string &filename)
  {
    return StripFileExtension( ExtractFilename(filename) );
  }
  static inline std::string GetFileExtension(const std::string &filename)
  {
    if (filename.find_last_of(".") != std::string::npos)
      return StringToLowerCase( filename.substr(filename.find_last_of(".")+1) );
    return "";
  }
  static bool Exists(const std::string filename)
  {
    struct stat buffer;
    if (stat(filename.c_str(), &buffer) != -1)
        return true;
    return false;
  }

#ifndef VTK_ONLY

  static inline void MakeDirectory(std::string name)
  {
    itksys::SystemTools::MakeDirectory( itksys::SystemTools::GetRealPath(name) );
  }
#endif

protected:

private:

};

#ifndef VTK_ONLY
template<class TImage>
bool File::OpenImage(const std::string filename, typename itk::SmartPointer<TImage> &data)
{
  if(!Exists(filename))
  {
    std::cerr << "File " << filename << " doesn't exist. Ignoring." << std::endl;
    return false;
  }

  data = ReadImageUsingITK<TImage>(filename);

  if(!data)
    return false;

  return true;
}

#if (ITK_VERSION_MAJOR > 3)
  template<class TImage, size_t TDim>
  //template<class TPixel, class TDim>
  bool File::OpenAsVectorImage(const std::string filename, typename itk::SmartPointer< itk::VectorImage< typename TImage::InternalPixelType, TDim> > &data)
  {
    if(!Exists(filename))
    {
      std::cerr << "File " << filename << " doesn't exist. Ignoring." << std::endl;
      return false;
    }

    typename TImage::Pointer image = ReadImageUsingITK<TImage>(filename);

    if(!image)
      return false;

    typedef itk::Image< typename TImage::InternalPixelType, TDim > TImageSlice;
    typedef itk::ComposeImageFilter<TImageSlice> ImageToVectorImageFilterType;
    typename ImageToVectorImageFilterType::Pointer imageToVectorImageFilter = ImageToVectorImageFilterType::New();
    typename TImage::SizeType size = image->GetLargestPossibleRegion().GetSize();
    std::cout << "Image Size: " << size[0] << "x" << size[1] << "x" << size[2] << "x" << size[3] << std::endl;
    for(size_t j = 0; j < size[3]; j ++)
    {
      typename TImage::IndexType desiredStart; 
      desiredStart.Fill(0);
      desiredStart[3] = j;

      typename TImage::SizeType desiredSize;
      desiredSize[0] = size[0];
      desiredSize[1] = size[1];
      desiredSize[2] = size[2];
      desiredSize[3] = 0; //Needs to be zero to create slice

      typename TImage::RegionType desiredRegion(desiredStart, desiredSize);

      typedef itk::ExtractImageFilter<TImage, TImageSlice> FilterType;
      typename FilterType::Pointer filter = FilterType::New();
      filter->SetExtractionRegion(desiredRegion);
      filter->SetInput(image);
    #if ITK_VERSION_MAJOR >= 4
      filter->SetDirectionCollapseToIdentity(); // This is required.
    #endif
      filter->Update();

      imageToVectorImageFilter->SetInput(j, filter->GetOutput());
    }
    imageToVectorImageFilter->Update();

    data = imageToVectorImageFilter->GetOutput();

    if(!data)
      return false;

    return true;
  }
#endif

template<class TImage>
bool File::OpenImages(std::vector<std::string> &filenames, std::vector< typename itk::SmartPointer<TImage> > &images)
{
  if(filenames.empty())
    return false;

  std::vector<std::string> readFilenames;
  for(size_t j = 0; j < filenames.size(); j ++)
  {
    typename itk::SmartPointer<TImage> image;
    bool success = OpenImage(filenames[j], image);
    if(success && image)
    {
      readFilenames.push_back(filenames[j]);
      images.push_back(image);
    }
  }

  if(images.empty())
    return false;
  filenames = readFilenames;

  return true;
}

template<class TImage>
bool File::SaveImage(const std::string filename, typename itk::SmartPointer<TImage> data, itk::ImageIOBase *io)
{
  typedef itk::ImageFileWriter<TImage> ImageWriter;

  typename ImageWriter::Pointer writer = ImageWriter::New();
    writer->UseInputMetaDataDictionaryOn();
    writer->SetInput(data);
    writer->SetFileName(filename.c_str());
    if(io)
      writer->SetImageIO(io);
    writer->AddObserver(itk::ProgressEvent(), ProgressUpdates);
    try
    {
      writer->Update();
    }
    catch( itk::ExceptionObject & err )
    {
      std::cerr << "File Exception caught while writing!" << std::endl;
      std::cerr << err << std::endl;
      return false;
    }

  return true;
}

template<class TImage>
bool File::SaveImages(std::vector<std::string> &filenames, const std::vector< typename itk::SmartPointer<TImage> > images)
{
  if(filenames.empty())
    return false;

  std::vector<std::string> readFilenames;
  for(size_t j = 0; j < filenames.size(); j ++)
  {
    bool success = SaveImage<TImage>(filenames[j], images[j]);
    if(success && images[j])
      readFilenames.push_back(filenames[j]);
  }

  if(images.empty())
    return false;
  filenames = readFilenames;

  return true;
}

//DICOM related
template<class TImage>
bool File::GetDICOMData(const std::string directoryPath, typename itk::SmartPointer<TImage> &data, itk::MetaDataDictionary &dict, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive)
{
  typedef itk::ImageSeriesReader<TImage> ReaderType;
  typedef itk::GDCMImageIO ImageIOType;

  const std::vector<std::string> filenames = GetDICOMSeriesFilenames(directoryPath, seriesName, recursive);

  ImageIOType::Pointer gdcmIO = ImageIOType::New();
  typename ReaderType::Pointer reader = ReaderType::New();
  reader->SetImageIO(gdcmIO);
  reader->SetFileNames(filenames);
  reader->AddObserver(itk::ProgressEvent(), ProgressUpdates);
  try
  {
    reader->Update();
  }
  catch (itk::ExceptionObject &excp)
  {
    std::cerr << "File Exception caught while reading series!" << std::endl;
    std::cerr << excp << std::endl;
    return false;
  }

  typedef itk::MetaDataObject< std::string > MetaDataStringType;
  std::string series_type_id("0008|103e");
  itk::MetaDataDictionary & dic = gdcmIO->GetMetaDataDictionary();
  itk::MetaDataDictionary::ConstIterator series_type_itr = dic.Find(series_type_id);
  std::string caseId = "0010|0020";
  itk::MetaDataDictionary::ConstIterator case_itr = dic.Find(caseId);
  std::string echoNumber = "0018|0086";
  itk::MetaDataDictionary::ConstIterator echoNumber_itr = dic.Find(echoNumber);
  std::string seriesNumber = "0020|0011";
  itk::MetaDataDictionary::ConstIterator seriesNumber_itr = dic.Find(seriesNumber);
  std::string acqNumber = "0020|0012";
  itk::MetaDataDictionary::ConstIterator acqNumber_itr = dic.Find(acqNumber);
  std::string instanceNumber = "0020|0013";
  itk::MetaDataDictionary::ConstIterator instanceNumber_itr = dic.Find(instanceNumber);
  std::string itemNumber = "0020|0019";
  itk::MetaDataDictionary::ConstIterator itemNumber_itr = dic.Find(itemNumber);

  MetaDataStringType::ConstPointer entryValue = dynamic_cast<const MetaDataStringType *>(series_type_itr->second.GetPointer());
  if (entryValue)
  {
    seriesName = entryValue->GetMetaDataObjectValue();
    std::cout << "Series: " << entryValue->GetMetaDataObjectValue() << std::endl;
  }
  MetaDataStringType::ConstPointer entryValue2 = dynamic_cast<const MetaDataStringType *>(case_itr->second.GetPointer());
  if (entryValue2)
  {
    caseID = entryValue2->GetMetaDataObjectValue();
    std::cout << "Case: " << entryValue2->GetMetaDataObjectValue() << std::endl;
  }
  MetaDataStringType::ConstPointer entryValue3;
  if (dic.HasKey(echoNumber))
  {
    entryValue3 = dynamic_cast<const MetaDataStringType *>(echoNumber_itr->second.GetPointer());
    echoID = entryValue3->GetMetaDataObjectValue();
    std::cout << "Echo Number: " << entryValue3->GetMetaDataObjectValue() << std::endl;
  }
  MetaDataStringType::ConstPointer entryValue4;
  if (dic.HasKey(seriesNumber))
  {
    entryValue4 = dynamic_cast<const MetaDataStringType *>(seriesNumber_itr->second.GetPointer());
    seriesID = entryValue4->GetMetaDataObjectValue();
    std::cout << "Series Number: " << entryValue4->GetMetaDataObjectValue() << std::endl;
  }
  MetaDataStringType::ConstPointer entryValue5;
  if (dic.HasKey(acqNumber))
  {
    entryValue5 = dynamic_cast<const MetaDataStringType *>(acqNumber_itr->second.GetPointer());
    acqID = entryValue5->GetMetaDataObjectValue();
    std::cout << "Acquisition Number: " << entryValue5->GetMetaDataObjectValue() << std::endl;
  }
  MetaDataStringType::ConstPointer entryValue6;
  if (dic.HasKey(instanceNumber))
  {
    entryValue6 = dynamic_cast<const MetaDataStringType *>(instanceNumber_itr->second.GetPointer());
    instanceID = entryValue6->GetMetaDataObjectValue();
    std::cout << "Instance Number: " << entryValue6->GetMetaDataObjectValue() << std::endl;
  }
  MetaDataStringType::ConstPointer entryValue7;
  if (dic.HasKey(itemNumber))
  {
    entryValue7 = dynamic_cast<const MetaDataStringType *>(itemNumber_itr->second.GetPointer());
    std::cout << "Item Number: " << entryValue7->GetMetaDataObjectValue() << std::endl;
  }

  dict = gdcmIO->GetMetaDataDictionary();
  data = reader->GetOutput();

  return true;
}

template<class TImage>
bool File::GetDICOMMetaData(const std::string directoryPath, itk::MetaDataDictionary &dict, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive)
{
  typename itk::SmartPointer<TImage> data;

  if (!GetDICOMData<TImage>(directoryPath, data, dict, seriesName, caseID, echoID, seriesID, acqID, instanceID, recursive))
    return false;

  return true;
}

template<class TImage>
bool File::GetDICOMTags(const std::string directoryPath, std::vector< std::pair<std::string, std::string> > &tags, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive)
{
  typedef itk::MetaDataObject< std::string > MetaDataStringType;
  typedef itk::MetaDataDictionary DictionaryType;
  DictionaryType dictionary;
  if (!GetDICOMMetaData<TImage>(directoryPath, dictionary, seriesName, caseID, echoID, seriesID, acqID, instanceID, recursive))
    return false;

  DictionaryType::ConstIterator itr = dictionary.Begin();
  DictionaryType::ConstIterator end = dictionary.End();

  while (itr != end)
  {
    itk::MetaDataObjectBase::Pointer entry = itr->second;
    MetaDataStringType::Pointer entryvalue = dynamic_cast<MetaDataStringType *>(entry.GetPointer());
    std::string entryTag = itr->first;
    if (entryvalue) //convert MetaDataObject pair to string pair
    {
      std::pair<std::string, std::string> entryPair = std::make_pair(entryTag, entryvalue->GetMetaDataObjectValue());
      tags.push_back(entryPair);
    }
    ++itr;
  }

  return true;
}

template<class TImage>
bool File::GetDICOMTags(const itk::MetaDataDictionary dictionary, std::vector< std::pair<std::string, std::string> > &tags)
{
  typedef itk::MetaDataObject< std::string > MetaDataStringType;
  typedef itk::MetaDataDictionary DictionaryType;

  DictionaryType::ConstIterator itr = dictionary.Begin();
  DictionaryType::ConstIterator end = dictionary.End();

  while (itr != end)
  {
    itk::MetaDataObjectBase::Pointer entry = itr->second;
    MetaDataStringType::Pointer entryvalue = dynamic_cast<MetaDataStringType *>(entry.GetPointer());
    std::string entryTag = itr->first;
    if (entryvalue) //convert MetaDataObject pair to string pair
    {
      std::pair<std::string, std::string> entryPair = std::make_pair(entryTag, entryvalue->GetMetaDataObjectValue());
      tags.push_back(entryPair);
    }
    ++itr;
  }

  return true;
}

template<class TImage>
bool File::OpenDICOMSeries(const std::string directoryPath, typename itk::SmartPointer<TImage> &data, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive)
{
  typedef itk::MetaDataDictionary DictionaryType;
  DictionaryType dictionary;

  if (!GetDICOMData<TImage>(directoryPath, data, dictionary, seriesName, caseID, echoID, seriesID, acqID, instanceID, recursive))
    return false;

  return true;
}

template<class TImage>
bool File::OpenDICOMSeriesAndTags(const std::string directoryPath, typename itk::SmartPointer<TImage> &data, std::vector< std::pair<std::string, std::string> > &tags, std::string &seriesName, std::string &caseID, std::string &echoID, std::string &seriesID, std::string &acqID, std::string &instanceID, bool recursive)
{
  typedef itk::MetaDataDictionary DictionaryType;
  DictionaryType dictionary;

  if (!GetDICOMData<TImage>(directoryPath, data, dictionary, seriesName, caseID, echoID, seriesID, acqID, instanceID, recursive))
    return false;

  if (!milx::File::GetDICOMTags<TImage>(dictionary, tags))
    return false;

  return true;
}
#endif

#ifndef ITK_ONLY
  #ifndef VTK_ONLY
  template<class TImage>
  bool File::OpenImage(const std::string filename, vtkSmartPointer<vtkImageData> &data)
  {
    std::string extension = GetFileExtension(filename);
    vtkSmartPointer<vtkErrorWarning> errorObserver = vtkSmartPointer<vtkErrorWarning>::New();

    if(!Exists(filename))
      return false;

    if(extension == "vti") //VTK XML Image format
    {
      vtkSmartPointer<vtkXMLImageDataReader> reader = vtkSmartPointer<vtkXMLImageDataReader>::New();

      if(reader->CanReadFile(filename.c_str()))
      {
          reader->SetFileName(filename.c_str());
          reader->AddObserver(vtkCommand::ErrorEvent, errorObserver);
          //~ linkProgressEventOf(reader);
          reader->Update();

          if(!errorObserver->ReportsFailure())
          {
              data = reader->GetOutput();
          }
          else
          {
              std::cerr << "VTK XML Image Reader Encountered the following error." << std::endl;
              std::cerr << errorObserver->GetMessage() << std::endl;
              return false;
          }
      }
      else
      {
          std::cerr << "Could not locate VTK XML Image (VTI) file!" << std::endl;
          return false;
      }
    }
    else
    {
      typename itk::SmartPointer<TImage> tmpImage;

      if( !OpenImage(filename, tmpImage) )
        return false;

      typedef itk::ImageToVTKImageFilter<TImage> ConnectorType;
      typename ConnectorType::Pointer connector = ConnectorType::New(); 
        connector->SetInput(tmpImage);
        connector->Update();

      vtkSmartPointer<vtkImageFlip> imageReorient = vtkSmartPointer<vtkImageFlip>::New();
      #if VTK_MAJOR_VERSION <= 5
        imageReorient->SetInput(connector->GetOutput());
      #else
        imageReorient->SetInputData(connector->GetOutput());
      #endif
        imageReorient->SetFilteredAxis(1);
        imageReorient->FlipAboutOriginOn();
        imageReorient->AddObserver(vtkCommand::ErrorEvent, errorObserver);
        imageReorient->Update();

      if(errorObserver->ReportsFailure())
      {
        std::cerr << "Reader Encountered the following error." << endl;
        std::cerr << errorObserver->GetMessage() << endl;
        return false;
      }

      data = imageReorient->GetOutput();
    }

    return true;
  }

  template<class TImage>
  bool File::SaveImage(const std::string filename, vtkSmartPointer<vtkImageData> &data)
  {
    std::string extension = GetFileExtension(filename);

    vtkSmartPointer<vtkErrorWarning> errorObserver = vtkSmartPointer<vtkErrorWarning>::New();
    vtkSmartPointer<vtkImageFlip> imageReorient = vtkSmartPointer<vtkImageFlip>::New();
    #if VTK_MAJOR_VERSION <= 5
      imageReorient->SetInput(data);
    #else
      imageReorient->SetInputData(data);
    #endif
      imageReorient->SetFilteredAxis(1);
      imageReorient->FlipAboutOriginOn();
      imageReorient->AddObserver(vtkCommand::ErrorEvent, errorObserver);
      imageReorient->Update();

    if(errorObserver->ReportsFailure())
    {
      std::cerr << "Writer Encountered the following error." << std::endl;
      std::cerr << errorObserver->GetMessage() << std::endl;
      return false;
    }

    if(extension == "vti") //VTK XML Image format
    {
      vtkSmartPointer<vtkXMLImageDataWriter> writer = vtkSmartPointer<vtkXMLImageDataWriter>::New();
      #if VTK_MAJOR_VERSION <= 5
        writer->SetInput(data);
      #else
        writer->SetInputData(data);
      #endif
        writer->SetFileName(filename.c_str());
        writer->SetDataModeToBinary();
        writer->AddObserver(vtkCommand::ErrorEvent, errorObserver);
        //~ linkProgressEventOf(writer);
        writer->Write();

      if(errorObserver->ReportsFailure())
      {
          std::cerr << "VTK XML Image Writer Encountered the following error." << std::endl;
          std::cerr << errorObserver->GetMessage() << std::endl;
      }
    }
    else
    {
      typedef itk::VTKImageToImageFilter<TImage> ConnectorType;
      typename ConnectorType::Pointer connector = ConnectorType::New(); 
        connector->SetInput(imageReorient->GetOutput());
        connector->Update();

      if( !SaveImage<TImage>(filename, connector->GetOutput()) )
        return false;
    }

    return true;
  }
  #endif
#endif

#ifndef VTK_ONLY
template<class TImage>
itk::SmartPointer<TImage> File::ReadImageUsingITK(const std::string filename)
{
  typedef itk::ImageFileReader<TImage, itk::DefaultConvertPixelTraits<typename TImage::InternalPixelType> > ImageReader; //InternalPixelType != PixelType for vector images
  typename ImageReader::Pointer reader = ImageReader::New();
  reader->SetFileName(filename.c_str());
  reader->AddObserver(itk::ProgressEvent(), milx::ProgressUpdates);
  try
  {
    reader->Update();
  }
  catch( itk::ExceptionObject & err )
  {
    std::cerr << "Reader Encountered the following error." << std::endl;
    std::cerr << err << std::endl;
    return NULL;
  }

  return reader->GetOutput();
}

template<class TImage>
bool File::WriteImageUsingITK(const std::string filename, itk::SmartPointer<TImage> data)
{
  typedef itk::ImageFileWriter<TImage> ImageWriter;
  typename ImageWriter::Pointer writer = ImageWriter::New();
  writer->SetFileName(filename.c_str());
  writer->SetInput(data);
  writer->AddObserver(itk::ProgressEvent(), milx::ProgressUpdates);
  try
  {
    writer->Update();
  }
  catch( itk::ExceptionObject & err )
  {
    std::cerr << "Writer Encountered the following error." << std::endl;
    std::cerr << err << std::endl;
    return false;
  }

  return true;
}

template<class TType>
itk::SmartPointer< itk::Transform<TType> > File::OpenTransform(std::string filename)
{
  typedef itk::TransformFileReader        TransformReaderType;
  typedef TransformReaderType::TransformListType * TransformListType;

  // Register default transforms
  itk::TransformFactoryBase::RegisterDefaultTransforms();

  TransformReaderType::Pointer affineReader = TransformReaderType::New();
  affineReader->SetFileName(filename);
  affineReader->AddObserver(itk::ProgressEvent(), milx::ProgressUpdates);
  try
  {
    affineReader->Update();
  }
  catch(itk::ExceptionObject &ex)
  {
    PrintError("milxFile: Failed reading Transform " + std::string(ex.GetDescription()));
    return NULL;
  }

  return static_cast< itk::Transform<TType> *>( (*(affineReader->GetTransformList()->begin())).GetPointer() );
}
#endif

} //end namespace milx

#endif //__MILXFILE_H