itkGDCMImageIO.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  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.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkGDCMImageIO_h
#define itkGDCMImageIO_h
 
#include "itkCommonEnums.h"
#include "itkImageIOBase.h"
#include "ITKIOGDCMExport.h"
#include <fstream>
#include <string>
 
 
#if !defined(ITK_LEGACY_REMOVE)
#  define ITKIO_DEPRECATED_GDCM1_API
#endif
 
 
namespace itk
{
class GDCMImageIOEnums
{
public:
  enum class Compression : uint8_t
  {
    JPEG = 0,
    JPEG2000,
    JPEGLS,
    RLE
  };
};
 
// Define how to print enumeration
extern ITKIOGDCM_EXPORT std::ostream &
                        operator<<(std::ostream & out, const GDCMImageIOEnums::Compression value);
class InternalHeader;
class ITKIOGDCM_EXPORT GDCMImageIO : public ImageIOBase
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(GDCMImageIO);
  using Self = GDCMImageIO;
  using Superclass = ImageIOBase;
  using Pointer = SmartPointer<Self>;
 
  itkNewMacro(Self);
 
  itkOverrideGetNameOfClassMacro(GDCMImageIO);
 
  /*-------- This part of the interface deals with reading data. ------ */
 
  bool
  CanReadFile(const char *) override;
 
  void
  ReadImageInformation() override;
 
  void
  Read(void * pointer) override;
 
  itkGetEnumMacro(InternalComponentType, itk::CommonEnums::IOComponent);
  itkSetEnumMacro(InternalComponentType, itk::CommonEnums::IOComponent);
  /*-------- This part of the interfaces deals with writing data. ----- */
 
  bool
  CanWriteFile(const char *) override;
 
  void
  WriteImageInformation() override;
 
  void
  Write(const void * buffer) override;
 
  itkGetConstMacro(RescaleSlope, double);
  itkGetConstMacro(RescaleIntercept, double);
  itkGetStringMacro(UIDPrefix);
  itkSetStringMacro(UIDPrefix);
  itkGetStringMacro(StudyInstanceUID);
  itkGetStringMacro(SeriesInstanceUID);
  itkGetStringMacro(FrameOfReferenceInstanceUID);
  itkSetMacro(KeepOriginalUID, bool);
  itkGetConstMacro(KeepOriginalUID, bool);
  itkBooleanMacro(KeepOriginalUID);
  itkSetMacro(LoadPrivateTags, bool);
  itkGetConstMacro(LoadPrivateTags, bool);
  itkBooleanMacro(LoadPrivateTags);
  itkSetMacro(ReadYBRtoRGB, bool);
  itkGetConstMacro(ReadYBRtoRGB, bool);
  itkBooleanMacro(ReadYBRtoRGB);
#if defined(ITKIO_DEPRECATED_GDCM1_API)
 
  void
  GetPatientName(char * name, size_t len = 512);
 
  void
  GetPatientID(char * name, size_t len = 512);
 
  void
  GetPatientSex(char * name, size_t len = 512);
 
  void
  GetPatientAge(char * name, size_t len = 512);
 
  void
  GetStudyID(char * name, size_t len = 512);
 
  void
  GetPatientDOB(char * name, size_t len = 512);
 
  void
  GetStudyDescription(char * name, size_t len = 512);
 
  void
  GetBodyPart(char * name, size_t len = 512);
 
  void
  GetNumberOfSeriesInStudy(char * name, size_t len = 512);
 
  void
  GetNumberOfStudyRelatedSeries(char * name, size_t len = 512);
 
  void
  GetStudyDate(char * name, size_t len = 512);
 
  void
  GetModality(char * name, size_t len = 512);
 
  void
  GetManufacturer(char * name, size_t len = 512);
 
  void
  GetInstitution(char * name, size_t len = 512);
 
  void
  GetModel(char * name, size_t len = 512);
 
  void
  GetScanOptions(char * name, size_t len = 512);
#endif
 
  bool
  GetValueFromTag(const std::string & tag, std::string & value);
 
  static bool
  GetLabelFromTag(const std::string & tag, std::string & labelId);
 
#if defined(ITKIO_DEPRECATED_GDCM1_API)
 
  virtual void
  SetMaxSizeLoadEntry(const long)
  {}
 
  virtual void
  SetLoadSequences(const bool)
  {}
  virtual bool
  GetLoadSequences() const
  {
    return true;
  }
  virtual void
  LoadSequencesOn()
  {}
  virtual void
  LoadSequencesOff()
  {}
  static void
  SetLoadSequencesDefault(bool)
  {}
  static void
  LoadSequencesDefaultOn()
  {}
  static void
  LoadSequencesDefaultOff()
  {}
  static bool
  GetLoadSequencesDefault()
  {
    return true;
  }
  static void
  SetLoadPrivateTagsDefault(bool)
  {}
  static void
  LoadPrivateTagsDefaultOn()
  {}
  static void
  LoadPrivateTagsDefaultOff()
  {}
  static bool
  GetLoadPrivateTagsDefault()
  {
    return true;
  }
#endif
 
  using CompressionEnum = GDCMImageIOEnums::Compression;
#if !defined(ITK_LEGACY_REMOVE)
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr CompressionEnum JPEG = CompressionEnum::JPEG;
  static constexpr CompressionEnum JPEG2000 = CompressionEnum::JPEG2000;
  static constexpr CompressionEnum JPEGLS = CompressionEnum::JPEGLS;
  static constexpr CompressionEnum RLE = CompressionEnum::RLE;
#endif
 
  itkSetEnumMacro(CompressionType, CompressionEnum);
  itkGetEnumMacro(CompressionType, CompressionEnum);
 
  void
  InternalSetCompressor(const std::string & _compressor) override;
 
protected:
  GDCMImageIO();
  ~GDCMImageIO() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  InternalReadImageInformation();
 
  double m_RescaleSlope{};
 
  double m_RescaleIntercept{};
 
  std::string m_UIDPrefix{};
 
  std::string m_StudyInstanceUID{};
 
  std::string m_SeriesInstanceUID{};
 
  std::string m_FrameOfReferenceInstanceUID{};
 
  bool m_KeepOriginalUID{};
 
  bool m_LoadPrivateTags{};
 
  bool m_ReadYBRtoRGB{};
 
private:
#if defined(ITKIO_DEPRECATED_GDCM1_API)
  std::string m_PatientName{};
 
  std::string m_PatientID{};
 
  std::string m_PatientDOB{};
 
  std::string m_StudyID{};
 
  std::string m_StudyDescription{};
 
  std::string m_BodyPart{};
 
  std::string m_NumberOfSeriesInStudy{};
 
  std::string m_NumberOfStudyRelatedSeries{};
 
  std::string m_PatientSex{};
 
  std::string m_PatientAge{};
 
  std::string m_StudyDate{};
 
  std::string m_Modality{};
 
  std::string m_Manufacturer{};
 
  std::string m_Institution{};
 
  std::string m_Model{};
 
  std::string m_ScanOptions{};
#endif
 
  unsigned int m_GlobalNumberOfDimensions{};
 
  CompressionEnum m_CompressionType{};
 
  bool m_SingleBit{};
 
  IOComponentEnum m_InternalComponentType{};
 
  InternalHeader * m_DICOMHeader{};
};
 
} // end namespace itk
 
#endif // itkGDCMImageIO_h