volume_cpu.h

#pragma once

#include "volume.h"
#include "volume_allocator_cpu.h"

template<typename, int> class ndarray_ref;

namespace iu {
template<typename PixelType, class Allocator>
class VolumeCpu : public Volume
{
public:
  typedef PixelType pixel_type;

  VolumeCpu() :
    Volume(),
    data_(0), pitch_(0), ext_data_pointer_(false)
  {
  }

  virtual ~VolumeCpu()
  {
    if(!ext_data_pointer_)
    {
      // do not delete externally handeled data pointers.
      Allocator::free(data_);
      data_ = 0;
    }
    pitch_ = 0;
  }

  VolumeCpu(unsigned int _width, unsigned int _height, unsigned int _depth) :
    Volume(_width, _height, _depth),
    data_(0), pitch_(0),
    ext_data_pointer_(false)
  {
    data_ = Allocator::alloc(_width, _height, _depth, &pitch_);
  }

  VolumeCpu(const iu::Size<3>& size) :
    Volume(size), data_(0), pitch_(0),
    ext_data_pointer_(false)
  {
    data_ = Allocator::alloc(size.width, size.height, size.depth, &pitch_);
  }

  VolumeCpu(PixelType* _data, unsigned int _width, unsigned int _height, unsigned int _depth,
            size_t _pitch, bool ext_data_pointer = false) :
    Volume(_width, _height, _depth),
    data_(0), pitch_(0), ext_data_pointer_(ext_data_pointer)
  {
    if(ext_data_pointer_)
    {
      // This uses the external data pointer as internal data pointer.
      data_ = _data;
      pitch_ = _pitch;
    }
    else
    {
      // allocates an internal data pointer and copies the external data onto it.
      if(_data == 0)
        return;

      data_ = Allocator::alloc(_width, _height, _depth, &pitch_);
      Allocator::copy(_data, _pitch, data_, pitch_, this->size());
    }
  }

  size_t bytes() const
  {
    return depth()*height()*pitch_;
  }

  size_t pitch() const
  {
    return pitch_;
  }

  size_t slice_pitch() const
  {
    return height()*pitch_;
  }

  size_t stride() const
  {
    return pitch_/sizeof(PixelType);
  }

  size_t slice_stride() const
  {
    return height()*pitch_/sizeof(PixelType);
  }

  virtual unsigned int bitDepth() const
  {
    return 8*sizeof(PixelType);
  }

  virtual bool onDevice() const
  {
    return false;
  }

  PixelType* data(int ox = 0, int oy = 0, int oz = 0)
  {
    return &data_[oz*slice_stride() + oy*stride() + ox];
  }

  const PixelType* data(int ox = 0, int oy = 0, int oz = 0) const
  {
    return reinterpret_cast<const PixelType*>(
          &data_[oz*slice_stride() + oy*stride() + ox]);
  }

  ImageCpu<PixelType, iuprivate::ImageAllocatorCpu<PixelType> > getSlice(int oz)
  {
    return ImageCpu<PixelType, iuprivate::ImageAllocatorCpu<PixelType> >(&data_[oz*slice_stride()], width(), height(), pitch_, true);
  }
  
  PixelType getPixel(unsigned int x, unsigned int y, unsigned int z)
  {
    return *data(x, y, z);
  }

  thrust::pointer<PixelType, thrust::host_system_tag> begin(void)
  {
      return thrust::pointer<PixelType, thrust::host_system_tag>(data());
  }

  thrust::pointer<PixelType, thrust::host_system_tag> end(void)
  {
      return thrust::pointer<PixelType, thrust::host_system_tag>(data()+slice_stride()*depth());
  }

  ndarray_ref<PixelType,3> ref() const;

  VolumeCpu(const ndarray_ref<PixelType,3> &x);

protected:

private:
  PixelType* data_;
  size_t pitch_;
  bool ext_data_pointer_;

private:
  VolumeCpu(const VolumeCpu&);
  VolumeCpu& operator=(const VolumeCpu&);
};

} // namespace iuprivate