sitkImage.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 sitkImage_h
#define sitkImage_h
 
#include "sitkCommon.h"
#include "sitkTemplateFunctions.h"
#include "sitkDetail.h"
#include "sitkPixelIDTokens.h"
#include "sitkInterpolator.h"
 
#include <vector>
#include <memory>
#include <type_traits>
 
namespace itk
{
 
// Forward declaration for pointer
class DataObject;
 
template <class T>
class SmartPointer;
 
namespace simple
{
 
// This is the forward declaration of a class used internally to the
// Image class, but the actual interface is not exposed to simple
// ITK. A pointer to the implementation is used as per the pimple
// idiom.
class PimpleImageBase;

class SITKCommon_EXPORT Image
{
public:
  using Self = Image;
 
  virtual ~Image();

  Image();
 
  // copy constructor
  Image(const Image & img);
 
  Image &
  operator=(const Image & img);
 
#ifndef SWIG
  Image(Image && img) noexcept;
  Image &
  operator=(Image && img) noexcept;

  Image
  ProxyForInPlaceOperation();
#endif
 

  Image(unsigned int width, unsigned int height, PixelIDValueEnum valueEnum);
  Image(unsigned int width, unsigned int height, unsigned int depth, PixelIDValueEnum valueEnum);
  Image(const std::vector<unsigned int> & size, PixelIDValueEnum valueEnum, unsigned int numberOfComponents = 0);
 

  template <typename TImageType>
  explicit Image(itk::SmartPointer<TImageType> image)
    : Image(image.GetPointer())
  {}
 
  template <typename TImageType>
  explicit Image(TImageType * image)
    : Image()
  {
    const PixelIDValueType type = ImageTypeToPixelIDValue<TImageType>::Result;
    const unsigned int     dimension = TImageType::ImageDimension;
 
    static_assert(type != sitkUnknown, "invalid pixel type");
    static_assert(dimension >= 2 && dimension <= SITK_MAX_DIMENSION, "Unsupported image dimension.");
 
    this->InternalInitialization(type, dimension, image);
  }


  itk::DataObject *
  GetITKBase();
  const itk::DataObject *
  GetITKBase() const;

  PixelIDValueEnum
  GetPixelID() const;
  PixelIDValueType
  GetPixelIDValue() const;

  std::string
  GetPixelIDTypeAsString() const;

  unsigned int
  GetDimension() const;

  unsigned int
  GetNumberOfComponentsPerPixel() const;

  uint64_t
  GetNumberOfPixels() const;

  unsigned int
  GetSizeOfPixelComponent() const;

  std::vector<double>
  GetOrigin() const;
  void
  SetOrigin(const std::vector<double> & origin);

  std::vector<double>
  GetSpacing() const;
  void
  SetSpacing(const std::vector<double> & spacing);

  std::vector<double>
  GetDirection() const;
  void
  SetDirection(const std::vector<double> & direction);

  std::vector<double>
  TransformIndexToPhysicalPoint(const std::vector<int64_t> & index) const;

  std::vector<int64_t>
  TransformPhysicalPointToIndex(const std::vector<double> & point) const;

  std::vector<double>
  TransformPhysicalPointToContinuousIndex(const std::vector<double> & point) const;

  std::vector<double>
  TransformContinuousIndexToPhysicalPoint(const std::vector<double> & index) const;

  std::vector<double>
  EvaluateAtContinuousIndex(const std::vector<double> & index, InterpolatorEnum interp = sitkLinear) const;

  std::vector<double>
  EvaluateAtPhysicalPoint(const std::vector<double> & point, InterpolatorEnum interp = sitkLinear) const;
 

  bool
  IsCongruentImageGeometry(const Image & otherImage, double coordinateTolerance, double directionTolerance) const;

  bool
  IsSameImageGeometryAs(const Image & otherImage,
                        double = DefaultImageCoordinateTolerance,
                        double = DefaultImageDirectionTolerance) const;

  std::vector<unsigned int>
  GetSize() const;

  unsigned int
  GetWidth() const;

  unsigned int
  GetHeight() const;

  unsigned int
  GetDepth() const;
 

  void
  CopyInformation(const Image & srcImage);

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

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

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

  void
  SetMetaData(const std::string & key, const std::string & value);

  bool
  EraseMetaData(const std::string & key);
 
  std::string
  ToString() const;

  Image
  ToVectorImage(bool inPlace = true);

  Image
  ToScalarImage(bool inPlace = true);

  int8_t
  GetPixelAsInt8(const std::vector<uint32_t> & idx) const;
  uint8_t
  GetPixelAsUInt8(const std::vector<uint32_t> & idx) const;
  int16_t
  GetPixelAsInt16(const std::vector<uint32_t> & idx) const;
  uint16_t
  GetPixelAsUInt16(const std::vector<uint32_t> & idx) const;
  int32_t
  GetPixelAsInt32(const std::vector<uint32_t> & idx) const;
  uint32_t
  GetPixelAsUInt32(const std::vector<uint32_t> & idx) const;
  int64_t
  GetPixelAsInt64(const std::vector<uint32_t> & idx) const;
  uint64_t
  GetPixelAsUInt64(const std::vector<uint32_t> & idx) const;
  float
  GetPixelAsFloat(const std::vector<uint32_t> & idx) const;
  double
  GetPixelAsDouble(const std::vector<uint32_t> & idx) const;
 
  std::vector<int8_t>
  GetPixelAsVectorInt8(const std::vector<uint32_t> & idx) const;
  std::vector<uint8_t>
  GetPixelAsVectorUInt8(const std::vector<uint32_t> & idx) const;
  std::vector<int16_t>
  GetPixelAsVectorInt16(const std::vector<uint32_t> & idx) const;
  std::vector<uint16_t>
  GetPixelAsVectorUInt16(const std::vector<uint32_t> & idx) const;
  std::vector<int32_t>
  GetPixelAsVectorInt32(const std::vector<uint32_t> & idx) const;
  std::vector<uint32_t>
  GetPixelAsVectorUInt32(const std::vector<uint32_t> & idx) const;
  std::vector<int64_t>
  GetPixelAsVectorInt64(const std::vector<uint32_t> & idx) const;
  std::vector<uint64_t>
  GetPixelAsVectorUInt64(const std::vector<uint32_t> & idx) const;
  std::vector<float>
  GetPixelAsVectorFloat32(const std::vector<uint32_t> & idx) const;
  std::vector<double>
  GetPixelAsVectorFloat64(const std::vector<uint32_t> & idx) const;
 
  std::complex<float>
  GetPixelAsComplexFloat32(const std::vector<uint32_t> & idx) const;
  std::complex<double>
  GetPixelAsComplexFloat64(const std::vector<uint32_t> & idx) const;

  void
  SetPixelAsInt8(const std::vector<uint32_t> & idx, int8_t v);
  void
  SetPixelAsUInt8(const std::vector<uint32_t> & idx, uint8_t v);
  void
  SetPixelAsInt16(const std::vector<uint32_t> & idx, int16_t v);
  void
  SetPixelAsUInt16(const std::vector<uint32_t> & idx, uint16_t v);
  void
  SetPixelAsInt32(const std::vector<uint32_t> & idx, int32_t v);
  void
  SetPixelAsUInt32(const std::vector<uint32_t> & idx, uint32_t v);
  void
  SetPixelAsInt64(const std::vector<uint32_t> & idx, int64_t v);
  void
  SetPixelAsUInt64(const std::vector<uint32_t> & idx, uint64_t v);
  void
  SetPixelAsFloat(const std::vector<uint32_t> & idx, float v);
  void
  SetPixelAsDouble(const std::vector<uint32_t> & idx, double v);
 
  void
  SetPixelAsVectorInt8(const std::vector<uint32_t> & idx, const std::vector<int8_t> & v);
  void
  SetPixelAsVectorUInt8(const std::vector<uint32_t> & idx, const std::vector<uint8_t> & v);
  void
  SetPixelAsVectorInt16(const std::vector<uint32_t> & idx, const std::vector<int16_t> & v);
  void
  SetPixelAsVectorUInt16(const std::vector<uint32_t> & idx, const std::vector<uint16_t> & v);
  void
  SetPixelAsVectorInt32(const std::vector<uint32_t> & idx, const std::vector<int32_t> & v);
  void
  SetPixelAsVectorUInt32(const std::vector<uint32_t> & idx, const std::vector<uint32_t> & v);
  void
  SetPixelAsVectorInt64(const std::vector<uint32_t> & idx, const std::vector<int64_t> & v);
  void
  SetPixelAsVectorUInt64(const std::vector<uint32_t> & idx, const std::vector<uint64_t> & v);
  void
  SetPixelAsVectorFloat32(const std::vector<uint32_t> & idx, const std::vector<float> & v);
  void
  SetPixelAsVectorFloat64(const std::vector<uint32_t> & idx, const std::vector<double> & v);
 
  void
  SetPixelAsComplexFloat32(const std::vector<uint32_t> & idx, const std::complex<float> v);
  void
  SetPixelAsComplexFloat64(const std::vector<uint32_t> & idx, const std::complex<double> v);


  int8_t *
  GetBufferAsInt8();
  uint8_t *
  GetBufferAsUInt8();
  int16_t *
  GetBufferAsInt16();
  uint16_t *
  GetBufferAsUInt16();
  int32_t *
  GetBufferAsInt32();
  uint32_t *
  GetBufferAsUInt32();
  int64_t *
  GetBufferAsInt64();
  uint64_t *
  GetBufferAsUInt64();
  float *
  GetBufferAsFloat();
  double *
  GetBufferAsDouble();
  void *
  GetBufferAsVoid();
 
  const int8_t *
  GetBufferAsInt8() const;
  const uint8_t *
  GetBufferAsUInt8() const;
  const int16_t *
  GetBufferAsInt16() const;
  const uint16_t *
  GetBufferAsUInt16() const;
  const int32_t *
  GetBufferAsInt32() const;
  const uint32_t *
  GetBufferAsUInt32() const;
  const int64_t *
  GetBufferAsInt64() const;
  const uint64_t *
  GetBufferAsUInt64() const;
  const float *
  GetBufferAsFloat() const;
  const double *
  GetBufferAsDouble() const;
  const void *
  GetBufferAsVoid() const;
 

  void
  MakeUnique();

  bool
  IsUnique() const;
 
  static constexpr double DefaultImageCoordinateTolerance = 1e-6;
  static constexpr double DefaultImageDirectionTolerance = 1e-6;
 
protected:
  void
  Allocate(const std::vector<unsigned int> & size, PixelIDValueEnum valueEnum, unsigned int numberOfComponents);

  template <class TImageType>
  void
  AllocateInternal(const std::vector<unsigned int> & size, unsigned int numberOfComponents);

  template <class TImageType>
  Image
  ToVectorInternal(bool inPlace);
 
 
  template <class TImageType>
  Image
  ToScalarInternal(bool inPlace);

 
private:
  void
  InternalInitialization(PixelIDValueType type, unsigned int dimension, itk::DataObject * image);
 
 
  Image(std::unique_ptr<PimpleImageBase> pimpleImage);
 
 
  template <typename TImageType>
  PimpleImageBase *
  DispatchedInternalInitialization(itk::DataObject * image);
 
 
  friend struct DispatchedInternalInitialiationAddressor;
  friend struct AllocateMemberFunctionAddressor;
  friend struct ToVectorAddressor;
  friend struct ToScalarAddressor;
 
 
  std::unique_ptr<PimpleImageBase> m_PimpleImage;
};
 
} // namespace simple
} // namespace itk
 
#endif