mitkDICOMITKSeriesGDCMReader.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 mitkDICOMITKSeriesGDCMReader_h
#define mitkDICOMITKSeriesGDCMReader_h
 
#include <mutex>
#include <stack>
#include <mitkDICOMFileReader.h>
#include <mitkDICOMDatasetSorter.h>
#include <mitkDICOMGDCMImageFrameInfo.h>
#include <mitkEquiDistantBlocksSorter.h>
#include <mitkNormalDirectionConsistencySorter.h>
#include <MitkDICOMExports.h>
 
 
namespace itk
{
  class TimeProbesCollectorBase;
}
 
namespace mitk
{
 
class MITKDICOM_EXPORT DICOMITKSeriesGDCMReader : public DICOMFileReader
{
  public:
 
    mitkClassMacro( DICOMITKSeriesGDCMReader, DICOMFileReader );
    itkCloneMacro( DICOMITKSeriesGDCMReader );
    itkFactorylessNewMacro( DICOMITKSeriesGDCMReader );
    mitkNewMacro1Param( DICOMITKSeriesGDCMReader, unsigned int );
    mitkNewMacro2Param( DICOMITKSeriesGDCMReader, unsigned int, bool );
 
    void AnalyzeInputFiles() override;
 
    // void AllocateOutputImages();
    bool LoadImages() override;
 
    // re-implemented from super-class
    bool CanHandleFile(const std::string& filename) override;
 
    virtual void AddSortingElement(DICOMDatasetSorter* sorter, bool atFront = false);
 
    typedef const std::list<DICOMDatasetSorter::ConstPointer> ConstSorterList;
    ConstSorterList GetFreelyConfiguredSortingElements() const;
 
    void SetFixTiltByShearing(bool on);
 
    bool GetFixTiltByShearing() const;
 
    void SetAcceptTwoSlicesGroups(bool accept) const;
    bool GetAcceptTwoSlicesGroups() const;
 
    void SetToleratedOriginOffsetToAdaptive(double fractionOfInterSliceDistanct = 0.3) const;
 
    void SetToleratedOriginOffset(double millimeters = 0.005) const;
 
    void SetSimpleVolumeReading(bool read)
    {
      m_SimpleVolumeReading = read;
    };
 
    bool GetSimpleVolumeReading()
    {
      return m_SimpleVolumeReading;
    };
 
    double GetToleratedOriginError() const;
    bool IsToleratedOriginOffsetAbsolute() const;
 
    double GetDecimalPlacesForOrientation() const;
 
    bool operator==(const DICOMFileReader& other) const override;
 
    DICOMTagPathList GetTagsOfInterest() const override;
 
    static int GetDefaultDecimalPlacesForOrientation()
    {
      return m_DefaultDecimalPlacesForOrientation;
    }
 
    static bool GetDefaultSimpleVolumeImport()
    {
      return m_DefaultSimpleVolumeImport;
    }
 
    static bool GetDefaultFixTiltByShearing()
    {
      return m_DefaultFixTiltByShearing;
    }
 
  protected:
    mitkCloneMacro( DICOMITKSeriesGDCMReader );
 
    void InternalPrintConfiguration(std::ostream& os) const override;
 
    static std::string GetActiveLocale();
    void PushLocale() const;
    void PopLocale() const;
 
    const static int m_DefaultDecimalPlacesForOrientation = 5;
    const static bool m_DefaultSimpleVolumeImport = false;
    const static bool m_DefaultFixTiltByShearing = true;
 
    DICOMITKSeriesGDCMReader(unsigned int decimalPlacesForOrientation = m_DefaultDecimalPlacesForOrientation, bool simpleVolumeImport = m_DefaultSimpleVolumeImport);
    ~DICOMITKSeriesGDCMReader() override;
 
    DICOMITKSeriesGDCMReader(const DICOMITKSeriesGDCMReader& other);
    DICOMITKSeriesGDCMReader& operator=(const DICOMITKSeriesGDCMReader& other);
 
    using SortingBlockListItemType = std::pair<DICOMDatasetAccessingImageFrameList, IOVolumeSplitReason::Pointer>;
    using SortingBlockList = std::vector<SortingBlockListItemType> ;
    virtual SortingBlockList Condense3DBlocks(SortingBlockList& resultOf3DGrouping);
 
    virtual DICOMTagCache::Pointer GetTagCache() const;
    void SetTagCache( const DICOMTagCache::Pointer& ) override;
 
    static SortingBlockList InternalExecuteSortingStep(
        unsigned int sortingStepIndex,
        const DICOMDatasetSorter::Pointer& sorter,
        const SortingBlockList& input);
 
    virtual bool LoadMitkImageForOutput(unsigned int o);
 
    virtual bool LoadMitkImageForImageBlockDescriptor(DICOMImageBlockDescriptor& block) const;
 
    static ReaderImplementationLevel GetReaderImplementationLevel(const std::string sopClassUID);
  private:
 
    void EnsureMandatorySortersArePresent(unsigned int decimalPlacesForOrientation, bool simpleVolumeImport = false);
 
  protected:
 
    // NOT nice, made available to ThreeDnTDICOMSeriesReader due to lack of time
    bool m_FixTiltByShearing; // could be removed by ITKDICOMSeriesReader NOT flagging tilt unless requested to fix it!
 
    bool m_SimpleVolumeReading;
 
  private:
 
    SortingBlockList m_SortingResultInProgress;
 
    typedef std::list<DICOMDatasetSorter::Pointer> SorterList;
    SorterList m_Sorter;
 
  protected:
 
    // NOT nice, made available to ThreeDnTDICOMSeriesReader and ClassicDICOMSeriesReader due to lack of time
    mitk::EquiDistantBlocksSorter::Pointer m_EquiDistantBlocksSorter;
 
    mitk::NormalDirectionConsistencySorter::Pointer m_NormalDirectionConsistencySorter;
 
  private:
 
    static std::mutex s_LocaleMutex;
 
    mutable std::stack<std::string> m_ReplacedCLocales;
    mutable std::stack<std::locale> m_ReplacedCinLocales;
 
    double m_DecimalPlacesForOrientation;
 
    DICOMTagCache::Pointer m_TagCache;
    bool m_ExternalCache;
};
 
}
 
#endif