mlMultiFileVolume.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
 
#pragma once
 
#include "MLMultiFileVolumeSystem.h"
#include <mlZTUFileNameSet.h>
#include "mlMultiFileVolumeAdditionalOptions.h"
#include <mlDICOMCachedIOFileHandle.h>
#include <mlDICOMCachedIOProxies.h>
#include <mlDicomToMLTools.h>
 
#include <mlTypeDefs.h>
#include <FMEThirdPartyWarningsDisable.h>
#include <string>
#include <vector>
#include <FMEThirdPartyWarningsRestore.h>
#include <DCMTree_Lib.h>
 
ML_START_NAMESPACE
 
// Forwards to the internally used stuff.
class MLImageFormat;
class DicomMessageCollector;
class DicomConfigurableMessageFilter;
 
class MLMULTI_FILE_VOLUME_EXPORT MultiFileVolume {
  public:
 
    // --- Constants:
    static const char* const DDIVersionStringBase;
    
    static const char* const DDISMFTreeCacheFileSuffix;
    
    // --- Construction, destruction, initialization and important tools:
 
    MultiFileVolume();
 
    virtual ~MultiFileVolume();
 
    MultiFileVolume(const MultiFileVolume &ref);
 
    MultiFileVolume &operator=(const MultiFileVolume &ref);
 
    void setSMFTree(DCMTree::Const_StructuredMFPtr tree);
 
    const DCMTree::Const_StructuredMFPtr getSMFTree(bool checkImgProps = false) const;
 
    const DCMTree::Const_TreePtr getDCMTree(bool checkImgProps = false) const;
  
    DCMTree::Const_TreePtr getDCMTreeAlsoFromFiles() const;
 
    bool setUpIssues(const DicomMessageCollector *dcmMsgCollector=nullptr);
 
    std::string getIssues(const DicomMessageCollector *dcmMsgCollector=nullptr) const;
 
    const std::vector<std::string> &getIssuesVector() const;
 
    std::string getInfoDump(const std::string& cacheFileRootDirPath,
                            bool useRelativePaths,
                            const DicomMessageCollector *dcmMsgCollector=nullptr) const;
 
    MLErrorCode copyToSubImage(SubImage& outSubImg,
                               DicomMessageCollector& dcmMsgCollector);
 
    MLErrorCode copyToSubImage(SubImage& outSubImg,
                               PagedImage &,
                               DicomMessageCollector& dcmMsgCollector);
 
    // --- Persistence and comparison:
 
    bool equals(const MultiFileVolume& obj) const;
 
    std::string getVolumeInfoString(const std::string& lineEndStr, 
                                    const std::string& cacheFileRootDirPath,
                                    bool useRelativePaths,
                                    const std::string& userInfo=std::string()) const;
 
    MLErrorCode appendToCache(const std::string& cacheDirPath,
                              std::string& currCacheState,
                              const std::string& lineEndStr,
                              bool useRelativePaths,
                              const std::string &optionalFilePrefix = "");
 
    MLErrorCode setFromString(const std::string& state,
                              const std::string& cacheDirPath,
                              size_t& readPos,
                              bool lightLoad=false,
                              DicomMessageCollector *dcmMsgCollector=nullptr);
 
 
    // --- Other stuff:
 
    void appendFrameFile(MLint imgDim, const std::string& fileName, ImageVector& ext);
 
    MLErrorCode removeSpatialSlices(std::vector<size_t> zIndexesToRemove);
 
    static void setUpMetaDataDumpsFromAdditionalOptions(const MultiFileVolumeAdditionalOptions& additionalOptions,
                                                        PagedImage& imgProps);
 
    void setUpMetaDataDumpsFromAdditionalOptions();
 
 
    // --- Scalar Members for volume description.
 
    size_t getZExt() const { return _zExt; }
    void setZExt(size_t nZ) { _zExt = nZ; }
 
    size_t getTExt() const { return _tExt; }
    void setTExt(size_t nT) { _tExt = nT; }
 
    size_t getUExt() const { return _uExt; }
    void setUExt(size_t nU) { _uExt = nU; }
 
    int getFillValueUInt8() const { return _fillValueUInt8; }
    void setFillValueUInt8(int fVal) { _fillValueUInt8 = fVal; }
 
    int getPlanarConfig() const { return _planarConfig; }
    void setPlanarConfig(int pConfig) { _planarConfig = pConfig; }
 
    DicomToMLTools::FillPageMethods getFillPageMethod() const { return _fillPageMethod; }
    void setFillPageMethod(DicomToMLTools::FillPageMethods fpMode) { _fillPageMethod = fpMode; }
 
    // --- Complex Members for volume description.
 
    const DICOMCachedIOFileHandle& getFirstFileName() const { return _firstFileName; }
    void setFirstFileName(const std::string& fName) { _firstFileName = fName; }
 
    const std::string& getOutVolumeName() const { return _outVolumeName; }
    void setOutVolumeName(const std::string& fName) { _outVolumeName = fName; }
 
    const DICOMCachedIOFileHandle& getOvrDataSrcFile() const { return _ovrDataSrcFile; }
    void setOvrDataSrcFile(const std::string& oDFile) { _ovrDataSrcFile = oDFile; }
 
    const PagedImage& getImageProperties() const { return _imgProps; };
    PagedImage& getModifiableImageProperties() { return _imgProps; };
 
    void invalidateImage(const std::string& stateInfo, MLErrorCode stateErrCode);
 
    const std::string& getFileFormat() const { return _fileFormat; }
    void setFileFormat(const std::string& fFormat) { _fileFormat = fFormat; }
 
    ZTUFileNameSet& getModifiablePageFileNames() { return _pageFileNameSet; }
    const ZTUFileNameSet& getConstPageFileNames() const { return _pageFileNameSet; }
 
    const DICOMCachedIOFileHandle& getDicomSMFTagTreeCacheFileName() const { return _dicomSMFTagTreeCacheFileName; }
    void setDicomSMFTagTreeCacheFileName(const std::string& fName) { _dicomSMFTagTreeCacheFileName = fName; }
 
    const DICOMCachedIOFileHandle& getDirectDCMTreeFileName() const { return _directDCMTreeName; }
    void setDirectDCMTreeFileName(const std::string& fName) { _directDCMTreeName = fName; }
 
    MLdouble getImportTime() const { return _importTime; }
    void setImportTime(MLdouble iTime) { _importTime = iTime; }
    void addImportTime(MLdouble iTimeToAdd) { _importTime += iTimeToAdd; }
 
    const std::string& getInputFilterLabel() const { return _inputFilterLabel; }
    void setInputFilterLabel(const std::string& label) { _inputFilterLabel = label; }
 
    const std::string& getInputFilterConfig() const { return _inputFilterConfig; }
    void setInputFilterConfig(const std::string& config) { _inputFilterConfig = config; }
    
    MLImageFormat** getMLImageFormatFileLoaderPointer() { return &_mlImageFormatFileLoader; }
 
    Module** getMLItkImageFileReaderPointer() { return &_mlItkImageFileReader; }
    
    MultiFileVolumeAdditionalOptions &getAdditionalOptionsContainer() { return _additionalOptions; }
 
    bool searchFrameWithSOPInstanceUID(const std::string& sopInstanceUID,
                                       DICOMCachedIOFileHandle& foundHandle,
                                       DICOMTagTools::ZTUIndex& ztuPosition,
                                       bool forceSearchInEnhancedHandles,
                                       bool alsoSearchInSMFTrees,
                                       DicomMessageCollector& dcmMsgCollector) const;
 
    bool searchFrameWithValueInTag(DCMTree::RawTagId tagId,
                                   const std::string& tagValue,
                                   DICOMCachedIOFileHandle& foundHandle,
                                   DICOMTagTools::ZTUIndex& ztuPosition,
                                   bool forceSearchInEnhancedHandles,
                                   bool alsoSearchInSMFTrees,
                                   DicomMessageCollector& dcmMsgCollector) const;
 
    bool hasTagWithValueInTree(DCMTree::RawTagId tagId,
                               const std::string& tagValue,
                               bool alsoSearchInSMFTrees) const;
 
    void appendFilteredIssue(const std::string &issue,
                             const DicomMessageCollector *dcmMsgCollector,
                             bool separateWithTerminatorIfNecessary);
 
private:
    MLDICOMCachedIOProxies _cacheProxies;
 
    size_t _zExt;
 
    size_t _tExt;
 
    size_t _uExt;
 
    int _fillValueUInt8;
 
    int _planarConfig;
 
    DicomToMLTools::FillPageMethods _fillPageMethod;
 
    DICOMCachedIOFileHandle _firstFileName;
 
    std::string _outVolumeName;
 
    DICOMCachedIOFileHandle _ovrDataSrcFile;
 
    PagedImage _imgProps;
 
    std::string _fileFormat;
 
    ZTUFileNameSet _pageFileNameSet;
 
    DCMTree::Const_StructuredMFPtr _dicomSMFTagTree;
 
    DICOMCachedIOFileHandle _dicomSMFTagTreeCacheFileName;
 
    DICOMCachedIOFileHandle _directDCMTreeName;
 
    std::vector<std::string> _issues;
 
    MLdouble _importTime;
 
    std::string _inputFilterLabel;
 
    std::string _inputFilterConfig;
 
    MLImageFormat* _mlImageFormatFileLoader;
 
    Module* _mlItkImageFileReader;
    
    MultiFileVolumeAdditionalOptions _additionalOptions;
};
 
typedef MultiFileVolume DirectDicomImportVolumeReference;
 
ML_END_NAMESPACE