mitkIOUtil.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#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 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;
    };

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

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

    static std::vector<BaseData::Pointer> Load(const std::string &path, const IFileReader::Options &options);

    static DataStorage::SetOfObjects::Pointer Load(const std::vector<std::string> &paths, DataStorage &storage);

    static std::vector<BaseData::Pointer> Load(const std::vector<std::string> &paths);

    DEPRECATED(static int LoadFiles(const std::vector<std::string> &fileNames, DataStorage &storage));

    DEPRECATED(static DataStorage::Pointer LoadFiles(const std::vector<std::string> &fileNames));

    DEPRECATED(static mitk::BaseData::Pointer LoadBaseData(const std::string &path));

    DEPRECATED(static mitk::DataNode::Pointer LoadDataNode(const std::string &path));

    static mitk::Image::Pointer LoadImage(const std::string &path);

    static mitk::Surface::Pointer LoadSurface(const std::string &path);

    static mitk::PointSet::Pointer LoadPointSet(const std::string &path);

    static std::vector<BaseData::Pointer> Load(const us::ModuleResource &usResource,
                                               std::ios_base::openmode mode = std::ios_base::in);

    static void Save(const mitk::BaseData *data, const std::string &path);

    static void Save(const mitk::BaseData *data, const std::string &path, const IFileWriter::Options &options);

    static void Save(const mitk::BaseData *data,
                     const std::string &mimeType,
                     const std::string &path,
                     bool addExtension = true);

    static void Save(const mitk::BaseData *data,
                     const std::string &mimeType,
                     const std::string &path,
                     const mitk::IFileWriter::Options &options,
                     bool addExtension = true);

    static void Save(std::vector<SaveInfo> &saveInfos);

    DEPRECATED(static bool SaveImage(mitk::Image::Pointer image, const std::string &path));

    DEPRECATED(static bool SaveBaseData(mitk::BaseData *data, const std::string &path));

    DEPRECATED(static bool SaveSurface(mitk::Surface::Pointer surface, const std::string &path));

    DEPRECATED(static bool SavePointSet(mitk::PointSet::Pointer pointset, const std::string &path));

  protected:
    struct ReaderOptionsFunctorBase
    {
      virtual bool operator()(LoadInfo &loadInfo) = 0;
    };

    struct WriterOptionsFunctorBase
    {
      virtual bool operator()(SaveInfo &saveInfo) = 0;
    };

    static std::string Load(std::vector<LoadInfo> &loadInfos,
                            DataStorage::SetOfObjects *nodeResult,
                            DataStorage *ds,
                            ReaderOptionsFunctorBase *optionsCallback);

    static std::string Save(const BaseData *data,
                            const std::string &mimeType,
                            const std::string &path,
                            WriterOptionsFunctorBase *optionsCallback,
                            bool addExtension);

    static std::string Save(std::vector<SaveInfo> &saveInfos, WriterOptionsFunctorBase *optionsCallback);

  private:
    struct Impl;
  };
}

#endif // MITKIOUTIL_H