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>
 
 
namespace itk
{
class GDCMImageIOEnums
{
public:
  enum class Compression : uint8_t
  {
    JPEG = 0,
    JPEG2000,
    JPEGLS,
    RLE,
    HTJ2K
  };
};
 
// 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);

  bool
  GetValueFromTag(const std::string & tag, std::string & value);

  static bool
  GetLabelFromTag(const std::string & tag, std::string & labelId);
 
 
  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:
  unsigned int m_GlobalNumberOfDimensions{};
 
  CompressionEnum m_CompressionType{};
 
  bool m_SingleBit{};
 
  IOComponentEnum m_InternalComponentType{};
 
  InternalHeader * m_DICOMHeader{};
};
 
} // end namespace itk
 
#endif // itkGDCMImageIO_h