mitkDICOMImageBlockDescriptor.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 mitkDICOMImageBlockDescriptor_h
#define mitkDICOMImageBlockDescriptor_h
 
#include <mitkDICOMEnums.h>
#include <mitkDICOMImageFrameInfo.h>
#include <mitkDICOMTag.h>
#include <mitkDICOMTagCache.h>
#include <mitkIOVolumeSplitReason.h>
 
#include <mitkImage.h>
#include <mitkProperties.h>
#include <mitkWeakPointer.h>
#include <mitkIPropertyProvider.h>
 
#include <mitkGantryTiltInformation.h>
 
#include <unordered_map>
 
namespace mitk
{
 
  struct DICOMCachedValueInfo
  {
    unsigned int TimePoint;       
    unsigned int SliceInTimePoint; 
    std::string Value;            
  };
 
  class DICOMCachedValueLookupTable : public GenericLookupTable< DICOMCachedValueInfo >
  {
  public:
    typedef DICOMCachedValueLookupTable Self;
    typedef GenericLookupTable< DICOMCachedValueInfo >   Superclass;
    const char *GetNameOfClass() const override
    {
      return "DICOMCachedValueLookupTable";
    }
 
    DICOMCachedValueLookupTable() {}
    Superclass& operator=(const Superclass& other) override { return Superclass::operator=(other); }
    ~DICOMCachedValueLookupTable() override {}
  };
 
  class MITKDICOM_EXPORT DICOMImageBlockDescriptor: public IPropertyProvider
  {
  public:
 
    DICOMImageBlockDescriptor();
    ~DICOMImageBlockDescriptor() override;
 
    DICOMImageBlockDescriptor(const DICOMImageBlockDescriptor& other);
    DICOMImageBlockDescriptor& operator=(const DICOMImageBlockDescriptor& other);
 
    static DICOMTagList GetTagsOfInterest();
 
    void SetImageFrameList(const DICOMImageFrameList& framelist);
    const DICOMImageFrameList& GetImageFrameList() const;
 
    void SetMitkImage(Image::Pointer image);
    Image::Pointer GetMitkImage() const;
 
    ReaderImplementationLevel GetReaderImplementationLevel() const;
    void SetReaderImplementationLevel(const ReaderImplementationLevel& level);
 
    void SetProperty(const std::string& key, BaseProperty* value);
    BaseProperty* GetProperty(const std::string& key) const;
 
    std::string GetPropertyAsString(const std::string&) const;
 
    IOVolumeSplitReason::ConstPointer GetSplitReason() const;
    IOVolumeSplitReason::Pointer GetSplitReason();
    void SetSplitReason(IOVolumeSplitReason::Pointer reason);
 
    void SetFlag(const std::string& key, bool value);
    bool GetFlag(const std::string& key, bool defaultValue) const;
 
    void SetIntProperty(const std::string& key, int value);
    int GetIntProperty(const std::string& key, int defaultValue) const;
 
    BaseProperty::ConstPointer GetConstProperty(const std::string &propertyKey,
      const std::string &contextName = "",
      bool fallBackOnDefaultContext = true) const override;
 
    std::vector<std::string> GetPropertyKeys(const std::string &contextName = "",
      bool includeDefaultContext = false) const override;
 
    std::vector<std::string> GetPropertyContextNames() const override;
 
  private:
 
    // For future implementation: load slice-by-slice, mark this using these methods
    void SetSliceIsLoaded(unsigned int index, bool isLoaded);
    // For future implementation: load slice-by-slice, mark this using these methods
    bool IsSliceLoaded(unsigned int index) const;
    // For future implementation: load slice-by-slice, mark this using these methods
    bool AllSlicesAreLoaded() const;
 
  public:
 
    PixelSpacingInterpretation GetPixelSpacingInterpretation() const;
 
    void GetDesiredMITKImagePixelSpacing(ScalarType& spacingXinMM, ScalarType& spacingYinMM) const;
 
    void SetTiltInformation(const GantryTiltInformation& info);
    const GantryTiltInformation GetTiltInformation() const;
 
    void SetSOPClassUID(const std::string& uid);
    std::string GetSOPClassUID() const;
    std::string GetSOPClassUIDAsName() const;
 
    int GetNumberOfTimeSteps() const;
 
    int GetNumberOfFramesPerTimeStep() const;
 
    void SetTagCache(DICOMTagCache* privateCache);
 
    typedef std::map<DICOMTagPath, std::string> AdditionalTagsMapType;
    void SetAdditionalTagsOfInterest(const AdditionalTagsMapType& tagMap);
 
    typedef std::function<mitk::BaseProperty::Pointer(const DICOMCachedValueLookupTable&) > TagLookupTableToPropertyFunctor;
 
    void SetTagLookupTableToPropertyFunctor(TagLookupTableToPropertyFunctor);
 
 
    void Print(std::ostream& os, bool filenameDetails) const;
 
  private:
 
    // read values from tag cache
    std::string GetPixelSpacing() const;
    std::string GetImagerPixelSpacing() const;
 
    Image::Pointer FixupSpacing(Image* mitkImage);
    Image::Pointer DescribeImageWithProperties(Image* mitkImage);
    void UpdateImageDescribingProperties() const;
 
    static mitk::BaseProperty::Pointer GetPropertyForDICOMValues(const DICOMCachedValueLookupTable& cacheLookupTable);
 
    double stringtodouble(const std::string& str) const;
    DICOMImageFrameList m_ImageFrameList;
 
    Image::Pointer m_MitkImage;
    BoolList m_SliceIsLoaded;
    ReaderImplementationLevel m_ReaderImplementationLevel;
 
    GantryTiltInformation m_TiltInformation;
 
    PropertyList::Pointer m_PropertyList;
 
    IOVolumeSplitReason::Pointer m_SplitReason;
 
    WeakPointer<DICOMTagCache> m_TagCache;
 
    mutable bool m_PropertiesOutOfDate;
 
    AdditionalTagsMapType m_AdditionalTagMap;
    std::set<std::string> m_FoundAdditionalTags;
 
    TagLookupTableToPropertyFunctor m_PropertyFunctor;
  };
 
}
 
#endif