milxFile_Threaded.h

/*=========================================================================
  Copyright: (c) CSIRO, Australia

  This software is protected by international copyright laws.
  Any unauthorised copying, distribution or reverse engineering is prohibited.

  Licence:
  All rights in this Software are reserved to CSIRO. You are only permitted
  to have this Software in your possession and to make use of it if you have
  agreed to a Software License with CSIRO.
=========================================================================*/

#ifndef __MILXFILE_H
#define __MILXFILE_H

//STL
#include <string>
#include <algorithm>
#include <vector>
//ITK
#include <itkImage.h>
#include <itkMultiThreader.h>
#include <itkImageFileReader.h>
#include <itkImageFileWriter.h>
//VTK
#include <vtkSmartPointer.h>
#include <vtkCommand.h>
#include <vtkImageData.h>
#include <vtkImageFlip.h>
#include <vtkPolyData.h>
#include <vtkPolyDataCollection.h>
//MILX
#include "itkImageToVTKImageFilter.h"
#include "itkVTKImageToImageFilter.h"
//SMILI
#include <milxGlobal.h>

typedef std::string string; //Don't open std namespace

class VTK_COMMON_EXPORT vtkErrorWarning : public vtkCommand
{
public:
  static vtkErrorWarning* New()
  {
    return new vtkErrorWarning();
  }

  vtkTypeMacro(vtkErrorWarning, vtkCommand);

  inline const char* GetMessage()
  {
    return m_Message.c_str();
  }

  inline bool HasFailed()
  {
    return m_ErrorEncountered;
  }

  inline bool ReportsFailure()
  {
    return m_ErrorEncountered;
  }

  void Initialize()
  {
    m_ErrorEncountered = m_WarningEncountered = false;
  }

protected:
  vtkErrorWarning();
  ~vtkErrorWarning();

  bool m_ErrorEncountered;
  bool m_WarningEncountered;
  string m_Message;

private:
  void Execute(vtkObject *caller, unsigned long observedType, void* message);
};

namespace milx
{

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

public:
  //Images
  template<class Type, unsigned int Dimension>
  bool OpenImage(const string filename, typename itk::Image<Type, Dimension>::Pointer &data);
  template<class Type, unsigned int Dimension>
  bool OpenImage(const string filename, vtkSmartPointer<vtkImageData> &data);
  template<class Type, unsigned int Dimension>
  bool SaveImage(const string filename, typename itk::Image<Type, Dimension>::Pointer data);
  template<class Type, unsigned int Dimension>
  bool SaveImage(const string filename, vtkSmartPointer<vtkImageData> data);

  //Surfaces/Models
  static bool OpenModel(const string filename, vtkSmartPointer<vtkPolyData> &data);
  static bool OpenModelCollection(std::vector<string> filenames, vtkSmartPointer<vtkPolyDataCollection> &collection);
  static bool SaveModel(const string filename, vtkSmartPointer<vtkPolyData> data, const bool binary = false);
  static bool SaveModelCollection(std::vector<string> filenames, vtkSmartPointer<vtkPolyDataCollection> collection);

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

protected:
  struct ThreadStruct
  {
    typename itk::ProcessObject::Pointer Filter;
  };
  
  static ITK_THREAD_RETURN_TYPE ThreaderCallback( void *arg );
  
private:

};

// Callback routine used by the threading library. This routine just calls
// the ThreadedGenerateData method after setting the correct region for this
// thread. 
ITK_THREAD_RETURN_TYPE File::ThreaderCallback( void *arg )
{
  ThreadStruct *str;

  str = (ThreadStruct *)(((itk::MultiThreader::ThreadInfoStruct *)(arg))->UserData);

  try
  {
    str->Filter->Update();
  }
  catch( itk::ExceptionObject & err )
  {
    PrintError("File Exception caught!");
    err.Print(cerr);
  }
  
  return ITK_THREAD_RETURN_VALUE;
}

template<class Type, unsigned int Dimension>
bool File::OpenImage(const string filename, typename itk::Image<Type, Dimension>::Pointer &data)
{
  typedef itk::ImageFileReader< itk::Image<Type, Dimension> > ImageReader;
  
  ThreadStruct threadData;
  
  typename ImageReader::Pointer reader = ImageReader::New();
    reader->SetFileName(filename.c_str());
    threadData.Filter = reader;
    
  //Threading
  typedef itk::MultiThreader ThreaderType;
  
  ThreaderType::Pointer threader = ThreaderType::New();
    threader->SetNumberOfThreads( 1 );
    threader->SetSingleMethod( ThreaderCallback, &threadData );
    threader->SingleMethodExecute();  
    
  data = reader->GetOutput();
  
  return true;
}

template<class Type, unsigned int Dimension>
bool File::OpenImage(const string filename, vtkSmartPointer<vtkImageData> &data)
{
  typename itk::Image<Type, Dimension>::Pointer tmpImage;
  
  if( !OpenImage(filename, tmpImage) )
    return false;
  
  typedef itk::ImageToVTKImageFilter< itk::Image<Type, Dimension> > ConnectorType;
  typename ConnectorType::Pointer connector = ConnectorType::New(); 
    connector->SetInput(tmpImage);
    connector->Update();
  
  vtkSmartPointer<vtkImageFlip> imageReorient = vtkSmartPointer<vtkImageFlip>::New();
    imageReorient->SetInput(connector->GetOutput());
    imageReorient->SetFilteredAxis(1);
    imageReorient->FlipAboutOriginOn();
    imageReorient->Update();
  
  data = imageReorient->GetOutput();
  
  return true;
}

template<class Type, unsigned int Dimension>
bool File::SaveImage(const string filename, typename itk::Image<Type, Dimension>::Pointer data)
{
  typedef itk::ImageFileWriter< itk::Image<Type, Dimension> > ImageWriter;
  
  ThreadStruct threadData;
  
  typename ImageWriter::Pointer writer = ImageWriter::New();
    writer->SetFileName(filename.c_str());
    threadData.Filter = writer;
    
  //Threading
  typedef itk::MultiThreader ThreaderType;
  
  ThreaderType::Pointer threader = ThreaderType::New();
    threader->SetNumberOfThreads( 1 );
    threader->SetSingleMethod( ThreaderCallback, &threadData );
    threader->SingleMethodExecute();  
    
  return true;
}

template<class Type, unsigned int Dimension>
bool File::SaveImage(const string filename, vtkSmartPointer<vtkImageData> data)
{
  vtkSmartPointer<vtkImageFlip> imageReorient = vtkSmartPointer<vtkImageFlip>::New();
    imageReorient->SetInput(data);
    imageReorient->SetFilteredAxis(1);
    imageReorient->FlipAboutOriginOn();
    imageReorient->Update();
  
  typedef itk::VTKImageToImageFilter< itk::Image<Type, Dimension> > ConnectorType;
  typename ConnectorType::Pointer connector = ConnectorType::New(); 
    connector->SetInput(imageReorient->GetOutput());
    connector->Update();
  
  if( !SaveImage(filename, connector->GetOutput()) )
    return false;
  
  return true;
}

} //end namespace milx

#endif //__MILXFILE_H