sitkImageFileReader.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
 *
 *         http://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 sitkImageFileReader_h
#define sitkImageFileReader_h
 
#include "sitkMacro.h"
#include "sitkImage.h"
#include "sitkImageReaderBase.h"
#include "sitkMemberFunctionFactory.h"
 
 
namespace itk
{
 
class MetaDataDictionary;
 
namespace simple
{

class SITKIO_EXPORT ImageFileReader : public ImageReaderBase
{
public:
  using Self = ImageFileReader;
 
  ~ImageFileReader() override;
 
  ImageFileReader();

  std::string
  ToString() const override;

  std::string
  GetName() const override
  {
    return std::string("ImageFileReader");
  }
 
  void
  SetFileName(const PathType & fn);
  PathType
  GetFileName() const;
 
  Image
  Execute() override;
 
  // Interface methods to access image file's meta-data and image
  // information after calling Execute or after calling
  // MetaDataRead, which does not load the bulk pixel data.

  void
  ReadImageInformation();

  PixelIDValueEnum
  GetPixelID() const;
  PixelIDValueType
  GetPixelIDValue() const;
  unsigned int
  GetDimension() const;
  unsigned int
  GetNumberOfComponents() const;
  const std::vector<double> &
  GetOrigin() const;
  const std::vector<double> &
  GetSpacing() const;
  const std::vector<double> &
  GetDirection() const;
  const std::vector<uint64_t> &
  GetSize() const;

  bool
  CanStreamRead() const;

  std::vector<std::string>
  GetMetaDataKeys() const;

  bool
  HasMetaDataKey(const std::string & key) const;

  std::string
  GetMetaData(const std::string & key) const;
 

  void
  SetExtractSize(const std::vector<unsigned int> & size);
  const std::vector<unsigned int> &
  GetExtractSize() const;
 

  void
  SetExtractIndex(const std::vector<int> & index);
  const std::vector<int> &
  GetExtractIndex() const;
 
  typedef enum
  {
    COLLAPSETOIDENTITY,
    COLLAPSETOSUBMATRIX,
    COLLAPSETOGUESS
  } DirectionCollapseStrategyType;

  void
  SetDirectionCollapseToStrategy(DirectionCollapseStrategyType strategy);
  DirectionCollapseStrategyType
  GetDirectionCollapseToStrategy() const;
 
protected:
  template <class TImageType>
  Image
  ExecuteInternal(itk::ImageIOBase *);

  void
  UpdateImageInformationFromImageIO(itk::ImageIOBase * iobase);
 
private:
  // Internal method used implements extracting a region from the reader
  template <class TImageType, class TInternalImageType>
  Image
  ExecuteExtract(TInternalImageType * itkImage);
 
  // function pointer type
  typedef Image (Self::*MemberFunctionType)(itk::ImageIOBase *);
 
  // friend to get access to executeInternal member
  friend struct detail::MemberFunctionAddressor<MemberFunctionType>;
  static const detail::MemberFunctionFactory<MemberFunctionType> &
  GetMemberFunctionFactory();
 
 
  std::function<std::vector<std::string>()>       m_pfGetMetaDataKeys;
  std::function<bool(const std::string &)>        m_pfHasMetaDataKey;
  std::function<std::string(const std::string &)> m_pfGetMetaData;
 
  PathType m_FileName;
 
  std::unique_ptr<MetaDataDictionary> m_MetaDataDictionary;
 
  PixelIDValueEnum    m_PixelType{ sitkUnknown };
  unsigned int        m_Dimension{ 0 };
  unsigned int        m_NumberOfComponents{ 0 };
  std::vector<double> m_Direction;
  std::vector<double> m_Origin;
  std::vector<double> m_Spacing;
 
  std::vector<uint64_t> m_Size;
  bool                  m_CanStreamRead{ false };
 
  std::vector<unsigned int> m_ExtractSize;
  std::vector<int>          m_ExtractIndex;
 
  DirectionCollapseStrategyType m_DirectionCollapseToStrategy{ COLLAPSETOSUBMATRIX };
};

SITKIO_EXPORT Image
ReadImage(const PathType & filename, PixelIDValueEnum outputPixelType = sitkUnknown, const std::string & imageIO = "");
} // namespace simple
} // namespace itk
 
#endif