vtkMRMLFileIOManager.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware Inc.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  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 __vtkMRMLFileIOManager_h
#define __vtkMRMLFileIOManager_h
 
#include "vtkMRMLLogicExport.h"
 
#include <vtkObject.h>
#include <vtkSmartPointer.h>
#include <vtkWeakPointer.h>
 
#include <string>
#include <vector>
 
class vtkCollection;
class vtkImageData;
class vtkMRMLMessageCollection;
class vtkMRMLNode;
class vtkMRMLScene;
class vtkMRMLStorableNode;
class vtkMRMLStorageNode;
class vtkMRMLApplicationLogic;
class vtkMRMLFileIOHandler;
class vtkMRMLFileReader;
class vtkMRMLFileWriter;
class vtkMRMLIOProperties;
class vtkMRMLNodeWriter;
class vtkMRMLOperationProgress;

class VTK_MRML_LOGIC_EXPORT vtkMRMLFileIOManager : public vtkObject
{
public:
  static vtkMRMLFileIOManager* New();
  vtkTypeMacro(vtkMRMLFileIOManager, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum
  {
    HandlerRegisteredEvent = 24100,
    HandlerUnregisteredEvent,
    NewFileLoadedEvent,
    FileSavedEvent,
    OperationStartEvent,
    OperationProgressEvent,
    OperationEndEvent,
  };

  virtual void SetScene(vtkMRMLScene* scene);
  vtkMRMLScene* GetScene() const;

  void SetApplicationLogic(vtkMRMLApplicationLogic* applicationLogic);
  vtkMRMLApplicationLogic* GetApplicationLogic() const;


  void RegisterReader(vtkMRMLFileReader* reader);
  void RegisterWriter(vtkMRMLFileWriter* writer);
  void RegisterHandler(vtkMRMLFileIOHandler* handler);
  vtkMRMLNodeWriter* RegisterNodeWriter(const std::string& description,
                                        const std::string& fileType,
                                        const std::vector<std::string>& nodeClassNames,
                                        bool supportUseCompression = true);
  void UnregisterHandler(vtkMRMLFileIOHandler* handler);


  vtkMRMLFileReader* GetReaderByClassName(const std::string& className) const;
  vtkMRMLFileWriter* GetWriterByClassName(const std::string& className) const;


  int GetNumberOfReaders() const;
  vtkMRMLFileReader* GetNthReader(int index) const;
  int GetNumberOfWriters() const;
  vtkMRMLFileWriter* GetNthWriter(int index) const;



  std::vector<vtkSmartPointer<vtkMRMLFileReader>> GetReadersForFile(const std::string& filePath);
  vtkMRMLFileReader* GetReaderForFile(const std::string& filePath);
  std::string GetFileTypeForFile(const std::string& filePath);
  std::vector<std::string> GetFileTypesForFile(const std::string& filePath);
  std::vector<std::string> GetFileDescriptionsForFile(const std::string& filePath);

  vtkMRMLFileReader* GetReaderByDescription(const std::string& description);
  std::string GetFileTypeFromDescription(const std::string& description);
  std::vector<std::string> GetFileDescriptionsByType(const std::string& fileType);

  vtkMRMLFileReader* ExamineFileList(std::vector<std::string>& fileList, vtkMRMLIOProperties* ioProperties);



  std::vector<vtkSmartPointer<vtkMRMLFileWriter>> GetWritersForObject(vtkObject* object);
  vtkMRMLFileWriter* GetWriterForObject(vtkObject* object, const std::string& format = std::string());
  std::string GetFileWriterFileType(vtkObject* object, const std::string& format = std::string());
  std::string GetFileTypeForObject(vtkObject* object);
  std::vector<std::string> GetFileWriterDescriptions(const std::string& fileType);
  std::vector<std::string> GetFileWriterExtensions(vtkObject* object);


  std::vector<std::string> GetReaderFileTypes();
  std::vector<std::string> GetWriterFileTypes();
  std::vector<std::string> GetExtensionsForFileType(const std::string& fileType, bool writers);
  std::vector<std::string> GetNameFiltersForFileType(const std::string& fileType, bool writers);
  std::string GetDescriptionForFileType(const std::string& fileType, bool writers);
  std::vector<vtkSmartPointer<vtkMRMLFileReader>> GetReadersForFileType(const std::string& fileType);
  std::vector<vtkSmartPointer<vtkMRMLFileWriter>> GetWritersForFileType(const std::string& fileType);



  std::vector<std::string> GetAllWritableFileExtensions();
  std::vector<std::string> GetAllReadableFileExtensions();

  std::string GetCompleteSlicerWritableFileNameSuffix(vtkMRMLStorableNode* node);

  static std::string GetFileNameValidCharactersPattern();

  static std::string ForceFileNameValidCharacters(const std::string& filename);

  std::string ForceFileNameMaxLength(const std::string& filename, int extensionLength, int maxLength = -1);

  vtkGetMacro(DefaultMaximumFileNameLength, int);
  vtkSetMacro(DefaultMaximumFileNameLength, int);

  std::string ExtractKnownExtension(const std::string& fileName, vtkObject* object);

  std::string StripKnownExtension(const std::string& fileName, vtkObject* object);



  virtual bool LoadNodes(const std::string& fileType, //
                         vtkMRMLIOProperties* properties,
                         vtkCollection* loadedNodes = nullptr,
                         vtkMRMLMessageCollection* userMessages = nullptr);

  virtual bool LoadNodesFromList(vtkCollection* propertiesList, vtkCollection* loadedNodes = nullptr, vtkMRMLMessageCollection* userMessages = nullptr);

  vtkMRMLNode* LoadNodesAndGetFirst(const std::string& fileType, vtkMRMLIOProperties* properties, vtkMRMLMessageCollection* userMessages = nullptr);

  bool LoadScene(const std::string& fileName, bool clear = true, vtkMRMLMessageCollection* userMessages = nullptr);

  bool LoadFile(const std::string& fileName, vtkMRMLMessageCollection* userMessages = nullptr);



  bool SaveNodes(const std::string& fileType, vtkMRMLIOProperties* properties, vtkMRMLMessageCollection* userMessages = nullptr, vtkMRMLScene* scene = nullptr);

  bool ExportNodes(vtkCollection* propertiesList, bool hardenTransforms, vtkMRMLMessageCollection* userMessages = nullptr);

  bool ExportNodes(const std::vector<std::string>& nodeIDs,
                   const std::vector<std::string>& fileNames,
                   vtkMRMLIOProperties* commonProperties,
                   bool hardenTransforms,
                   vtkMRMLMessageCollection* userMessages = nullptr);

  bool SaveScene(const std::string& fileName, vtkImageData* screenShot = nullptr, vtkMRMLMessageCollection* userMessages = nullptr);

  void AddDefaultStorageNodes();

  static vtkMRMLStorageNode* CreateAndAddDefaultStorageNode(vtkMRMLStorableNode* node);

  void InvokeNewFileLoadedEvent(vtkMRMLIOProperties* loadedFileProperties);
  void InvokeFileSavedEvent(vtkMRMLIOProperties* savedFileProperties);

  vtkGetMacro(MaximumProgressUpdatesPerSecond, double);
  vtkSetMacro(MaximumProgressUpdatesPerSecond, double);

  std::string GetDefaultSceneFileType() const;
  void SetDefaultSceneFileType(const std::string& fileType);
 
protected:
  vtkMRMLFileIOManager();
  ~vtkMRMLFileIOManager() override;

  template <typename HandlerType>
  static std::vector<vtkSmartPointer<HandlerType>> SortedByConfidence(const std::vector<vtkSmartPointer<HandlerType>>& handlers, //
                                                                      const std::vector<double>& confidences);

  std::vector<vtkSmartPointer<vtkMRMLFileWriter>> GetWritersForFile(const std::string& fileType, vtkMRMLIOProperties* properties, vtkMRMLScene* scene);
 
  vtkWeakPointer<vtkMRMLScene> Scene;
  vtkWeakPointer<vtkMRMLApplicationLogic> ApplicationLogic;
  std::vector<vtkSmartPointer<vtkMRMLFileReader>> Readers;
  std::vector<vtkSmartPointer<vtkMRMLFileWriter>> Writers;
 
  std::string DefaultSceneFileType;
  int DefaultMaximumFileNameLength{ 1000 };

  bool StartOperationProgress(const std::string& title, int numberOfFiles);
  void EndOperationProgress(bool operationStarted, bool aborted = false);
  struct ListProgress
  {
    bool OperationStarted{ false };
    int NumberOfFiles{ 0 };
    int NumberOfProcessedFiles{ 0 };
    double RangeMinimum{ 0.0 };
    double RangeMaximum{ 1.0 };
    bool Aborted{ false };
  };

  ListProgress StartListProgress(const std::string& title, int numberOfFiles);
  void StartListItemProgress(ListProgress& listProgress, int fileIndex);
  bool EndListItemProgress(ListProgress& listProgress, int fileIndex);
  void EndListProgress(ListProgress& listProgress, vtkMRMLMessageCollection* userMessages, const std::string& abortedMessageFormat);

  bool ExportNode(vtkMRMLIOProperties* properties, vtkMRMLScene* temporaryScene, bool hardenTransforms, vtkMRMLMessageCollection* userMessages);

  void ReportFileProgress(double fileProgress, const std::string& text = std::string());
  static void OnSceneProgress(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

  void InvokeProgressEvent(bool force = false);
 
  double MaximumProgressUpdatesPerSecond{ 3.0 };
  double LastProgressEventTime{ 0.0 };
  bool ProgressEventPending{ false };

  vtkSmartPointer<vtkMRMLOperationProgress> OperationProgress;
  bool SceneProgressObserved{ false };
 
private:
  vtkMRMLFileIOManager(const vtkMRMLFileIOManager&) = delete;
  void operator=(const vtkMRMLFileIOManager&) = delete;
};
 
#endif