itkNiftiImageIO.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.
 *
 *=========================================================================*/
 
#ifndef itkNiftiImageIO_h
#define itkNiftiImageIO_h
#include "ITKIONIFTIExport.h"
 
 
#include <fstream>
#include <memory>
#include "itkImageIOBase.h"
 
 
namespace itk
{

class NiftiImageIOEnums
{
public:
  enum class Analyze75Flavor : uint8_t
  {

    AnalyzeITK4 = 4,

    AnalyzeFSL = 3,

    AnalyzeSPM = 2,

    AnalyzeITK4Warning = 1,

    AnalyzeReject = 0
  };

  enum class NiftiFileEnum : int8_t
  {
    TwoFileNifti = 2,

    OneFileNifti = 1,

    Analyze75 = 0,

    OtherOrError = -1,
  };
};

#if !defined(ITK_LEGACY_REMOVE)
using Analyze75Flavor = NiftiImageIOEnums::Analyze75Flavor;
#endif

extern ITKIONIFTI_EXPORT std::ostream &
                         operator<<(std::ostream & out, const NiftiImageIOEnums::Analyze75Flavor value);
extern ITKIONIFTI_EXPORT std::ostream &
                         operator<<(std::ostream & out, const NiftiImageIOEnums::NiftiFileEnum value);
class ITKIONIFTI_EXPORT NiftiImageIO : public ImageIOBase
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(NiftiImageIO);

  using Self = NiftiImageIO;
  using Superclass = ImageIOBase;
  using Pointer = SmartPointer<Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(NiftiImageIO);
 
  //-------- This part of the interfaces deals with reading data. -----
 
#if !defined(ITK_LEGACY_REMOVE)
  using FileType = NiftiImageIOEnums::NiftiFileEnum;
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr FileType TwoFileNifti = NiftiImageIOEnums::NiftiFileEnum::TwoFileNifti;
  static constexpr FileType OneFileNifti = NiftiImageIOEnums::NiftiFileEnum::OneFileNifti;
  static constexpr FileType Analyze75 = NiftiImageIOEnums::NiftiFileEnum::Analyze75;
  static constexpr FileType OtherOrError = NiftiImageIOEnums::NiftiFileEnum::OtherOrError;
#endif

  NiftiImageIOEnums::NiftiFileEnum
  DetermineFileType(const char * FileNameToRead);

  bool
  CanReadFile(const char * FileNameToRead) override;

  void
  ReadImageInformation() override;

  void
  Read(void * buffer) override;
 
  //-------- This part of the interfaces deals with writing data. -----

  bool
  CanWriteFile(const char * FileNameToWrite) override;

  void
  WriteImageInformation() override;

  void
  Write(const void * buffer) override;

  ImageIORegion
  GenerateStreamableReadRegionFromRequestedRegion(const ImageIORegion & requestedRegion) const override;

  itkSetMacro(RescaleSlope, double);
  itkSetMacro(RescaleIntercept, double);
  itkSetMacro(LegacyAnalyze75Mode, NiftiImageIOEnums::Analyze75Flavor);
  itkGetConstMacro(LegacyAnalyze75Mode, NiftiImageIOEnums::Analyze75Flavor);
  itkSetMacro(ConvertRASVectors, bool);
  itkGetConstMacro(ConvertRASVectors, bool);
  itkBooleanMacro(ConvertRASVectors);
  itkSetMacro(ConvertRASDisplacementVectors, bool);
  itkGetConstMacro(ConvertRASDisplacementVectors, bool);
  itkBooleanMacro(ConvertRASDisplacementVectors);
  itkSetMacro(SFORM_Permissive, bool);
  itkGetConstMacro(SFORM_Permissive, bool);
  itkBooleanMacro(SFORM_Permissive);
protected:
  NiftiImageIO();
  ~NiftiImageIO() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  virtual bool
  GetUseLegacyModeForTwoFileWriting() const
  {
    return false;
  }
 
private:
  // This proxy class has a nifti_image as a smart pointer to encapsulate access to the header.
  class NiftiImageProxy;
 
  std::unique_ptr<NiftiImageProxy> m_Holder;
 
  // Try to use the Q and S form codes from MetaDataDictionary if they are specified
  // there, otherwise default to the backwards compatible values from earlier
  // versions of ITK. The qform guess would probably been better to have
  // been guessed as NIFTI_XFORM_SCANNER_ANAT
  unsigned int
  getSFormCodeFromDictionary() const;
  unsigned int
  getQFormCodeFromDictionary() const;
 
  bool
  MustRescale() const;
 
  void
  DefineHeaderObjectDataType();
 
  void
  SetNIfTIOrientationFromImageIO(unsigned short origdims, unsigned short dims);
 
  void
  SetImageIOOrientationFromNIfTI(unsigned short dims, double spacingscale, double timingscale);
 
  void
  SetImageIOMetadataFromNIfTI();
 
  double m_RescaleSlope{ 1.0 };
  double m_RescaleIntercept{ 0.0 };
 
  bool m_ConvertRAS{ false };
  bool m_ConvertRASVectors{ false };
  bool m_ConvertRASDisplacementVectors{ true };
 
  IOComponentEnum m_OnDiskComponentType{ IOComponentEnum::UNKNOWNCOMPONENTTYPE };
 
  NiftiImageIOEnums::Analyze75Flavor m_LegacyAnalyze75Mode{};
 
  bool m_SFORM_Permissive{ false };
  bool m_SFORM_Corrected{ false };
};
 
 
} // end namespace itk
 
#endif // itkNiftiImageIO_h