itkImage.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 itkImage_h
#define itkImage_h
 
#include "itkImageRegion.h"
#include "itkImportImageContainer.h"
#include "itkDefaultPixelAccessor.h"
#include "itkDefaultPixelAccessorFunctor.h"
#include "itkPoint.h"
#include "itkFixedArray.h"
#include "itkWeakPointer.h"
#include "itkNeighborhoodAccessorFunctor.h"
 
#include <type_traits> // For is_same
 
namespace itk
{
template <typename TPixel, unsigned int VImageDimension = 2>
class ITK_TEMPLATE_EXPORT Image : public ImageBase<VImageDimension>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(Image);

  using Self = Image;
  using Superclass = ImageBase<VImageDimension>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  using ConstWeakPointer = WeakPointer<const Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(Image);

  using PixelType = TPixel;

  using ValueType = TPixel;

  using InternalPixelType = TPixel;
 
  using IOPixelType = PixelType;

  using AccessorType = DefaultPixelAccessor<PixelType>;
  using AccessorFunctorType = DefaultPixelAccessorFunctor<Self>;

  using NeighborhoodAccessorFunctorType = NeighborhoodAccessorFunctor<Self>;

  using typename Superclass::ImageDimensionType;

  using typename Superclass::IndexType;
  using typename Superclass::IndexValueType;

  using typename Superclass::OffsetType;

  using typename Superclass::SizeType;
  using typename Superclass::SizeValueType;

  using PixelContainer = ImportImageContainer<SizeValueType, PixelType>;

  using typename Superclass::DirectionType;

  using typename Superclass::RegionType;

  using typename Superclass::SpacingType;
  using typename Superclass::SpacingValueType;

  using typename Superclass::PointType;

  using PixelContainerPointer = typename PixelContainer::Pointer;
  using PixelContainerConstPointer = typename PixelContainer::ConstPointer;

  using typename Superclass::OffsetValueType;

  template <typename UPixelType, unsigned int VUImageDimension = VImageDimension>
  struct Rebind
  {
    using Type = itk::Image<UPixelType, VUImageDimension>;
  };
 
 
  template <typename UPixelType, unsigned int VUImageDimension = VImageDimension>
  using RebindImageType = itk::Image<UPixelType, VUImageDimension>;
 

  void
  Allocate(bool initializePixels = false) override;

  static Pointer
  CreateInitialized(const RegionType & region)
  {
    const auto image = Image::New();
    image->SetRegions(region);
    image->AllocateInitialized();
    return image;
  }

  void
  Initialize() override;

  void
  FillBuffer(const TPixel & value);

  void
  SetPixel(const IndexType & index, const TPixel & value)
  {
    const OffsetValueType offset = this->FastComputeOffset(index);
    (*m_Buffer)[offset] = value;
  }

  const TPixel &
  GetPixel(const IndexType & index) const
  {
    const OffsetValueType offset = this->FastComputeOffset(index);
    return (*m_Buffer)[offset];
  }

  TPixel &
  GetPixel(const IndexType & index)
  {
    const OffsetValueType offset = this->FastComputeOffset(index);
    return (*m_Buffer)[offset];
  }

  TPixel &
  operator[](const IndexType & index)
  {
    return this->GetPixel(index);
  }

  const TPixel &
  operator[](const IndexType & index) const
  {
    return this->GetPixel(index);
  }

  virtual TPixel *
  GetBufferPointer()
  {
    return m_Buffer ? m_Buffer->GetBufferPointer() : nullptr;
  }
  virtual const TPixel *
  GetBufferPointer() const
  {
    return m_Buffer ? m_Buffer->GetBufferPointer() : nullptr;
  }

  PixelContainer *
  GetPixelContainer()
  {
    return m_Buffer.GetPointer();
  }
 
  const PixelContainer *
  GetPixelContainer() const
  {
    return m_Buffer.GetPointer();
  }

  void
  SetPixelContainer(PixelContainer * container);

  virtual void
  Graft(const Self * image);

  AccessorType
  GetPixelAccessor()
  {
    return AccessorType();
  }

  const AccessorType
  GetPixelAccessor() const
  {
    return AccessorType();
  }

  NeighborhoodAccessorFunctorType
  GetNeighborhoodAccessor()
  {
    return NeighborhoodAccessorFunctorType();
  }

  const NeighborhoodAccessorFunctorType
  GetNeighborhoodAccessor() const
  {
    return NeighborhoodAccessorFunctorType();
  }
 
  [[nodiscard]] unsigned int
  GetNumberOfComponentsPerPixel() const override;

  template <typename TEqualityComparable>
  friend std::enable_if_t<std::is_same_v<TEqualityComparable, TPixel>, bool>
  operator==(const Image<TEqualityComparable, VImageDimension> & lhs,
             const Image<TEqualityComparable, VImageDimension> & rhs)
  {
    if ((lhs.GetBufferedRegion() != rhs.GetBufferedRegion()) || (lhs.m_Spacing != rhs.m_Spacing) ||
        (lhs.m_Origin != rhs.m_Origin) || (lhs.m_Direction != rhs.m_Direction) ||
        (lhs.m_InverseDirection != rhs.m_InverseDirection))
    {
      return false;
    }
 
    if (lhs.m_Buffer == rhs.m_Buffer)
    {
      return true;
    }
 
    if ((lhs.m_Buffer == nullptr) || (rhs.m_Buffer == nullptr))
    {
      return false;
    }
 
    auto & lhsBuffer = *(lhs.m_Buffer);
    auto & rhsBuffer = *(rhs.m_Buffer);
 
    const auto bufferSize = lhsBuffer.Size();
 
    if (bufferSize != rhsBuffer.Size())
    {
      return false;
    }
 
    const TEqualityComparable * const lhsBufferPointer = lhsBuffer.GetBufferPointer();
    const TEqualityComparable * const rhsBufferPointer = rhsBuffer.GetBufferPointer();
 
    return (lhsBufferPointer == rhsBufferPointer) ||
           std::equal(lhsBufferPointer, lhsBufferPointer + bufferSize, rhsBufferPointer);
  }

  template <typename TEqualityComparable>
  friend std::enable_if_t<std::is_same_v<TEqualityComparable, TPixel>, bool>
  operator!=(const Image<TEqualityComparable, VImageDimension> & lhs,
             const Image<TEqualityComparable, VImageDimension> & rhs)
  {
    return !(lhs == rhs);
  }
 
protected:
  Image() = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
  void
  Graft(const DataObject * data) override;
 
  ~Image() override = default;

  void
  ComputeIndexToPhysicalPointMatrices() override;
  using Superclass::Graft;
 
private:
  PixelContainerPointer m_Buffer{ PixelContainer::New() };
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImage.hxx"
#endif
 
#endif