volume.h

#pragma once

#include "coredefs.h"

#include <ostream>
#include <typeinfo>

namespace iu{
class Volume
{
public:
  Volume() :
    size_()
  {
  }

  virtual ~Volume()
  {
  }

  Volume(unsigned int width, unsigned int height, unsigned int depth) :
    size_(width, height, depth)
  {
  }

  Volume(const iu::Size<3> &size) :
    size_(size)
  {
  }

  bool sameType(const Volume &from)
  {
      return typeid(from)==typeid(*this);
  }

  iu::Size<3> size() const
  {
    return size_;
  }

  unsigned int width() const
  {
    return size_.width;
  }

  unsigned int height() const
  {
    return size_.height;
  }

  unsigned int depth() const
  {
    return size_.depth;
  }

  size_t numel() const
  {
    return (size_.width * size_.height * size_.depth);
  }

  virtual size_t bytes() const {return 0;};

  virtual size_t pitch() const {return 0;};

  virtual size_t stride() const {return 0;};

  virtual size_t slice_stride() const {return 0;};

  virtual unsigned int bitDepth() const {return 0;};

  virtual bool onDevice() const {return false;};

  friend std::ostream& operator<<(std::ostream & out,
                                  Volume const& volume)
  {
    out << "Volume: " << volume.size() << " stride="
        << volume.stride() << " slice_stride=" << volume.slice_stride()
        << " onDevice=" << volume.onDevice();
    return out;
  }

private:
  iu::Size<3> size_;

private:
  Volume(const Volume&);
  Volume& operator=(const Volume&);
};
 // end of Volume

} // namespace iuprivate