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