mitkIOUtil.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkIOUtil_h
#define mitkIOUtil_h
 
#include <MitkCoreExports.h>
#include <mitkDataStorage.h>
#include <mitkFileSystem.h>
#include <mitkImage.h>
#include <mitkPointSet.h>
#include <mitkSurface.h>
 
#include <mitkFileReaderSelector.h>
#include <mitkFileWriterSelector.h>
#include <mitkIFileReader.h>
#include <mitkIFileWriter.h>
 
#include <fstream>
 
#if !defined(MITK_WINDOWS_NO_UNDEF) && defined(GetTempPath)
  #undef GetTempPath
#endif
 
namespace us
{
  class ModuleResource;
}
 
namespace mitk
{
  class PropertyList;
 
  class MITKCORE_EXPORT IOUtil
  {
  public:
    struct MITKCORE_EXPORT LoadInfo
    {
      LoadInfo(const std::string &path);
 
      std::string m_Path;
      std::vector<BaseData::Pointer> m_Output;
 
      FileReaderSelector m_ReaderSelector;
      bool m_Cancel;
 
      const PropertyList* m_Properties;
    };
 
    struct MITKCORE_EXPORT ReaderOptionsFunctorBase
    {
      virtual bool operator()(LoadInfo &loadInfo) const = 0;
    };
 
    struct MITKCORE_EXPORT SaveInfo
    {
      SaveInfo(const BaseData *baseData, const MimeType &mimeType, const std::string &path);
 
      bool operator<(const SaveInfo &other) const;
 
      const BaseData *m_BaseData;
 
      FileWriterSelector m_WriterSelector;
      MimeType m_MimeType;
      std::string m_Path;
      bool m_Cancel;
    };
 
    struct MITKCORE_EXPORT WriterOptionsFunctorBase
    {
      virtual bool operator()(SaveInfo &saveInfo) const = 0;
    };
 
    static std::string GetProgramPath();
 
    enum class AppBundlePath
    {
      Parent,
      Self
    };
 
    static fs::path GetAppBundlePath(AppBundlePath path = AppBundlePath::Parent);
 
    static std::string GetTempPath();
 
    static char GetDirectorySeparator();
 
    static std::string CreateTemporaryFile(std::ofstream &tmpStream,
                                           const std::string &templateName = "XXXXXX",
                                           std::string path = std::string());
 
    static std::string CreateTemporaryFile(std::ofstream &tmpStream,
                                           std::ios_base::openmode mode,
                                           const std::string &templateName = "XXXXXX",
                                           std::string path = std::string());
 
    static std::string CreateTemporaryFile(const std::string &templateName = "XXXXXX",
                                           std::string path = std::string());
 
    static std::string CreateTemporaryDirectory(const std::string &templateName = "XXXXXX",
                                                std::string path = std::string());
 
    static DataStorage::SetOfObjects::Pointer Load(const std::string &path, DataStorage &storage,
                                                   const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
    static DataStorage::SetOfObjects::Pointer Load(const std::string &path,
                                                   const IFileReader::Options &options,
                                                   DataStorage &storage);
 
    static std::vector<BaseData::Pointer> Load(const std::string &path,
                                               const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
    template <typename T>
    static typename T::Pointer Load(const std::string& path, const ReaderOptionsFunctorBase *optionsCallback = nullptr)
    {
      return dynamic_cast<T*>(Load(path, optionsCallback).at(0).GetPointer());
    }
 
    static std::vector<BaseData::Pointer> Load(const std::string &path, const IFileReader::Options &options);
 
    template <typename T>
    static typename T::Pointer Load(const std::string& path, const IFileReader::Options &options)
    {
      return dynamic_cast<T*>(Load(path, options).at(0).GetPointer());
    }
 
    static DataStorage::SetOfObjects::Pointer Load(const std::vector<std::string> &paths, DataStorage &storage,
                                                   const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
    static std::vector<BaseData::Pointer> Load(const std::vector<std::string> &paths,
                                               const ReaderOptionsFunctorBase *optionsCallback = nullptr);
 
    static std::vector<BaseData::Pointer> Load(const us::ModuleResource &usResource,
                                               std::ios_base::openmode mode = std::ios_base::in);
 
    template <typename T>
    static typename T::Pointer Load(const us::ModuleResource &usResource, std::ios_base::openmode mode = std::ios_base::in)
    {
      return dynamic_cast<T*>(Load(usResource, mode).at(0).GetPointer());
    }
 
    static BaseData::Pointer Load(const std::string& path, const PropertyList* properties);
 
    static void Save(const mitk::BaseData *data, const std::string &path, bool setPathProperty = false);
 
    static void Save(const mitk::BaseData *data, const std::string &path, const IFileWriter::Options &options, bool setPathProperty = false);
 
    static void Save(const mitk::BaseData *data,
                     const std::string &mimeType,
                     const std::string &path,
                     bool addExtension = true,
                     bool setPathProperty = false);
 
    static void Save(const mitk::BaseData *data,
                     const std::string &mimeType,
                     const std::string &path,
                     const mitk::IFileWriter::Options &options,
                     bool addExtension = true,
                     bool setPathProperty = false);
 
    static void Save(std::vector<SaveInfo> &saveInfos, bool setPathProperty = false);
 
  protected:
    static std::string Load(std::vector<LoadInfo> &loadInfos,
                            DataStorage::SetOfObjects *nodeResult,
                            DataStorage *ds,
                            const ReaderOptionsFunctorBase *optionsCallback);
 
    static std::string Save(const BaseData *data,
                            const std::string &mimeType,
                            const std::string &path,
                            WriterOptionsFunctorBase *optionsCallback,
                            bool addExtension,
                            bool setPathProperty);
 
    static std::string Save(std::vector<SaveInfo> &saveInfos,
                            WriterOptionsFunctorBase *optionsCallback,
                            bool setPathProperty);
 
  private:
    struct Impl;
  };
}
 
#endif