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 <mitkImage.h>
#include <mitkPointSet.h>
#include <mitkSurface.h>

#include <mitkFileReaderSelector.h>
#include <mitkFileWriterSelector.h>
#include <mitkIFileReader.h>
#include <mitkIFileWriter.h>

#include <fstream>

namespace us
{
  class ModuleResource;
}

namespace mitk
{
  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;
    };

    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();

    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 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);

    static std::string Local8BitToUtf8(const std::string& local8BitStr);

    static std::string Utf8ToLocal8Bit(const std::string& utf8Str);

  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 // MITKIOUTIL_H