itkNDImageBase.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  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 itkNDImageBase_h
#define itkNDImageBase_h
 
#include "itkImage.h"
#include "itkArray.h"
#include <string>
#include "itkImageFileWriter.h"
 
namespace itk
{

 
template <typename TPixel>
class ITK_TEMPLATE_EXPORT NDImageBase : public Object
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(NDImageBase);

  using Self = NDImageBase;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  // itkNewMacro( Self );
  // not declared, because instantiating an object of this
  // (abstract) type makes no sense.

  itkOverrideGetNameOfClassMacro(NDImageBase);
 
  using DataObjectPointer = DataObject::Pointer;

  using PixelType = typename Image<TPixel, 2>::PixelType;
  using ValueType = typename Image<TPixel, 2>::ValueType;
  using InternalPixelType = typename Image<TPixel, 2>::InternalPixelType;
  using AccessorType = typename Image<TPixel, 2>::AccessorType;
  using PixelContainer = typename Image<TPixel, 2>::PixelContainer;
  using PixelContainerPointer = typename Image<TPixel, 2>::PixelContainerPointer;
  using PixelContainerConstPointer = typename Image<TPixel, 2>::PixelContainerConstPointer;
 
  using Spacing2DType = typename ImageBase<2>::SpacingType;
  using Point2DType = typename ImageBase<2>::PointType;
 
  using SpacingValueType = typename Spacing2DType::ValueType;
  using PointValueType = typename Point2DType::ValueType;
  using OffsetValueType = typename ImageBase<2>::OffsetValueType;

  using IndexType = Array<IndexValueType>;
  using SizeType = Array<SizeValueType>;
  using SpacingType = Array<SpacingValueType>;
  using PointType = Array<PointValueType>;
  using OffsetType = Array<OffsetValueType>;

 
  // using typename Superclass::RegionType;

 
  // void SetRegions(RegionType region) = 0;
  virtual void
  SetRegions(SizeType size) = 0;
 
  virtual void
  SetRequestedRegion(DataObject * data) = 0;
 
  virtual void
  Allocate() = 0;
 
  virtual void
  Initialize() = 0;
 
  virtual void
  FillBuffer(const TPixel & value) = 0;
 
  virtual void
  SetPixel(const IndexType & index, const TPixel & value) = 0;
 
  virtual const TPixel &
  GetPixel(const IndexType & index) const = 0;
 
  virtual TPixel &
  GetPixel(const IndexType & index) = 0;
 
  TPixel &
  operator[](const IndexType & index)
  {
    return this->GetPixel(index);
  }
  const TPixel &
  operator[](const IndexType & index) const
  {
    return this->GetPixel(index);
  }
 
  virtual TPixel *
  GetBufferPointer() = 0;
 
  virtual const TPixel *
  GetBufferPointer() const = 0;
 
  virtual PixelContainer *
  GetPixelContainer() = 0;
 
  virtual const PixelContainer *
  GetPixelContainer() const = 0;
 
  virtual void
  SetPixelContainer(PixelContainer * container) = 0;
 
  virtual AccessorType
  GetPixelAccessor() = 0;
 
  virtual const AccessorType
  GetPixelAccessor() const = 0;
 
  virtual void
  SetSpacing(const SpacingType & spacing) = 0;
 
  virtual void
  SetOrigin(const PointType & origin) = 0;
 
  /* Get Spacing/Origin return copies; not a const &, like
   * itkImage; necessary because of the conversion to arrays */
  virtual SpacingType
  GetSpacing() = 0;
 
  virtual PointType
  GetOrigin() = 0;

 
  virtual void
  CopyInformation(const DataObject * data) = 0;
 
  virtual const OffsetValueType *
  GetOffsetTable() const = 0;
 
  virtual OffsetValueType
  ComputeOffset(const IndexType & ind) const = 0;
 
  virtual IndexType
  ComputeIndex(OffsetValueType offset) const = 0;


  virtual unsigned int
  ImageDimension() = 0;
 
  virtual unsigned int
  GetImageDimension() = 0;
 
  virtual void
  SetImageIOWriter(ImageIOBase * _arg) = 0;
 
  virtual ImageIOBase *
  GetImageIOWriter() = 0;
 
  virtual void
  SetImageIOReader(ImageIOBase * _arg) = 0;
 
  virtual ImageIOBase *
  GetImageIOReader() = 0;

  virtual void
  Write() = 0;

  virtual void
  Read() = 0;

  virtual void
  CreateNewImage() = 0;

  virtual void
  SetOutputFileName(const char *) = 0;
 
  virtual void
  SetInputFileName(const char *) = 0;
 
  virtual const char *
  GetOutputFileName() = 0;
 
  virtual const char *
  GetInputFileName() = 0;
 
  static Pointer
  NewNDImage(unsigned int dim);
 
protected:
  NDImageBase() = default;
  ~NDImageBase() override = default;
 
  // virtual void PrintSelf(std::ostream& os, Indent indent) const = 0;
};
 
} // end namespace itk
 
#include "itkNDImageTemplate.h"
 
namespace itk
{
 
template <typename TPixel>
auto
NDImageBase<TPixel>::NewNDImage(unsigned int dim) -> Pointer
{
  switch (dim)
  {
    case 1:
      return NDImageTemplate<TPixel, 1>::New().GetPointer();
    case 2:
      return NDImageTemplate<TPixel, 2>::New().GetPointer();
    case 3:
      return NDImageTemplate<TPixel, 3>::New().GetPointer();
    case 4:
      return NDImageTemplate<TPixel, 4>::New().GetPointer();
    case 5:
      return NDImageTemplate<TPixel, 5>::New().GetPointer();
    // add here more dimensions if needed...
    // we could do this also with a recursive
    // template and a #define MAXDIM,
    // or something like that....
    default:
      return nullptr;
  }
}
 
 
} // end namespace itk
 
#endif // end #ifndef itkNDImageBase_h