image_cpu.h

#pragma once
#include <thrust/memory.h>
#include "image.h"
#include "image_allocator_cpu.h"

//#include "ndarray/ndarray_ref.host.h"
template<typename type, int dims> class ndarray_ref;

namespace boost
{
    namespace python
    {
        namespace api
        {
            class object;
        }
    }
}


namespace iu {

template<typename PixelType, class Allocator>
class ImageCpu : public Image
{
public:
  typedef PixelType pixel_type;

  ImageCpu() :
    Image(),
    data_(0), pitch_(0), ext_data_pointer_(false)
  {
  }

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

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

  ImageCpu(const iu::Size<2>& size) :
    Image(size.width, size.height), data_(0), pitch_(0),
    ext_data_pointer_(false)
  {
    data_ = Allocator::alloc(size.width, size.height, &pitch_);
  }

  ImageCpu(PixelType* _data, unsigned int _width, unsigned int _height,
           size_t _pitch, bool ext_data_pointer = false) :
    Image(_width, _height), data_(0), pitch_(0),
    ext_data_pointer_(ext_data_pointer)
  {
    if(ext_data_pointer_)
    {
      data_ = _data;
      pitch_ = _pitch;
    }
    else
    {
      data_ = Allocator::alloc(width(), height(), &pitch_);
      Allocator::copy(_data, _pitch, data_, pitch_, this->size());
    }
  }

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

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

  PixelType getPixel(unsigned int x, unsigned int y)
  {
    return *data(x, y);
  }

  PixelType* operator[](unsigned int row)
  {
    return data_+row*stride();
  }

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

  virtual size_t pitch() const
  {
    return pitch_;
  }

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

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

  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()+stride()*height());
  }

  virtual bool onDevice() const
  {
    return false;
  }

  ndarray_ref<PixelType,2> ref() const;

   ImageCpu(const ndarray_ref<PixelType,2> &x);

   ImageCpu(boost::python::api::object& py_arr);

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

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

} // namespace iu