DBaseImage.h

/*
 * Copyright (c) 2011-2016, Matthieu FAESSEL and ARMINES
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of Matthieu FAESSEL, or ARMINES nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef _D_BASE_IMAGE_H
#define _D_BASE_IMAGE_H
 
#include "DBaseObject.h"
#include "DSignal.h"
#include "DSlot.h"
#include "DCommon.h"
#include "DErrors.h"
 
#include "Gui/include/private/DImageViewer.hpp"
 
namespace smil
{
  class BaseImageViewer;
  template <class T> class ImageViewer;
 
  class BaseImage : public BaseObject
  {
    typedef BaseObject parentClass;
 
  public:
    BaseImage(const char *_className = "BaseImage")
        : BaseObject(_className), updatesEnabled(true), width(0), height(0),
          depth(0), pixelCount(0), lineCount(0), sliceCount(0),
          allocated(false), allocatedSize(0)
    {
      onModified = Signal(this);
      onShow     = Signal(this);
    }
 
    BaseImage(const BaseImage &rhs)
        : BaseObject(rhs), updatesEnabled(true), width(0), height(0), depth(0),
          pixelCount(0), lineCount(0), sliceCount(0), allocated(false),
          allocatedSize(0)
    {
      onModified = Signal(this);
      onShow     = Signal(this);
    }
 
    virtual ~BaseImage();
 
    // Forbid implicit assignment operator
    BaseImage &operator=(const BaseImage &rhs);
 
  public:
    virtual void init();
    inline size_t getWidth() const
    {
      return width;
    }
    inline size_t getHeight() const
    {
      return height;
    }
    inline size_t getDepth() const
    {
      return depth;
    }
 
    virtual size_t getAllocatedSize() const
    {
      return allocatedSize;
    }
 
    inline UINT getDimension() const
    {
      if (depth > 1)
        return 3;
      else if (height > 1)
        return 2;
      else
        return 1;
    }
 
    virtual RES_T setSize(size_t w, size_t h, size_t d = 1,
                          bool doAllocate = true) = 0;
 
    inline void getSize(size_t *w, size_t *h, size_t *d) const
    {
      *w = this->width;
      *h = this->height;
      *d = this->depth;
    }
 
#ifndef SWIGPYTHON
    inline void getSize(int *w, int *h, int *d) const
    {
      *w = this->width;
      *h = this->height;
      *d = this->depth;
    }
#endif // SWIGPYTHON
 
    inline void getSize(size_t s[3]) const
    {
      s[0] = this->width;
      s[1] = this->height;
      s[2] = this->depth;
    }
 
    inline void getSize(off_t s[3]) const
    {
      s[0] = this->width;
      s[1] = this->height;
      s[2] = this->depth;
    }
 
    inline void getSize(int s[3]) const
    {
      s[0] = this->width;
      s[1] = this->height;
      s[2] = this->depth;
    }
 
    inline size_t getPixelCount() const
    {
      return this->pixelCount;
    }
    inline size_t getLineCount() const
    {
      return this->lineCount;
    }
    inline size_t getSliceCount() const
    {
      return this->sliceCount;
    }
 
    inline bool isAllocated() const
    {
      return this->allocated;
    }
 
    virtual void *getVoidPointer() = 0;
    virtual void modified() = 0;
 
    inline bool areCoordsInImage(const off_t x, const off_t y, const off_t z = 0) const
    {
      if (x < 0 || y < 0 || z < 0)
        return false;
      if (x >= off_t(this->width) || y >= off_t(this->height) || z >= off_t(this->depth))
        return false;
      return true;
    }
 
    inline bool areCoordsInImage(const size_t x, const size_t y, const size_t z = 0) const
    {
      if (x >= size_t(this->width) || y >= size_t(this->height) || z >= size_t(this->depth))
        return false;
      return true;
    }
 
    inline bool isPointInImage(const IntPoint &p) const
    {
      if (p.x < 0 || p.y < 0 || p.z < 0)
        return false;
      if (p.x >= int(width) || p.y >= int(height) || p.z >= int(depth))
        return false;
      return true;
    }
 
 
    inline bool isOffsetInImage(const off_t offset) const
    {
      if (offset < 0)
        return false;
      if (offset > off_t(getPixelCount()))
        return false;
      return true;
    }
 
    inline bool isOffsetInImage(const size_t offset) const
    {
      if (offset > getPixelCount())
        return false;
      return true;
    }
 
    inline size_t getOffsetFromCoords(size_t x, size_t y, size_t z = 0) const
    {
      size_t vmax = numeric_limits<size_t>::max();
      if (x >= this->width)
        return vmax;
      if (y >= this->height)
        return vmax;
      if (z >= this->depth)
        return vmax;
      return z * this->width * this->height + y * this->width + x;
    }
 
    inline size_t getOffsetFromPoint(IntPoint &p) const
    {
      size_t vmax = numeric_limits<size_t>::max();
      if (p.x < 0 || p.y < 0 || p.z < 0)
        return vmax;
      if (p.x >= int(width))
        return vmax;
      if (p.y >= int(height))
        return vmax;
      if (p.z >= int(depth))
        return vmax;
      return p.z * width * height + p.y * width + p.x;
    }
 
    inline void getCoordsFromOffset(size_t off, size_t &x, size_t &y,
                                    size_t &z) const
    {
      z = off / (this->width * this->height);
      y = (off % (this->width * this->height)) / this->width;
      x = off % this->width;
    }
 
    inline void getCoordsFromOffset(off_t off, off_t &x, off_t &y,
                                    off_t &z) const
    {
      z = off / (this->width * this->height);
      y = (off % (this->width * this->height)) / this->width;
      x = off % this->width;
    }
 
    inline vector<size_t> getCoordsFromOffset(size_t off) const
    {
      vector<size_t> coords(3);
 
      coords[2] = off / (this->width * this->height);
      coords[1] = (off % (this->width * this->height)) / this->width;
      coords[0] = off % this->width;
      return coords;
    }
 
    inline IntPoint getPointFromOffset(size_t off) const
    {
      IntPoint pt;
 
      pt.z = off / (this->width * this->height);
      pt.y = (off % (this->width * this->height)) / this->width;
      pt.x = off % this->width;
      return pt;
    }
 
    virtual const char *getInfoString(const char * = "") const
    {
      return NULL;
    }
    virtual const char *getTypeAsString() = 0;
 
    virtual bool isVisible()
    {
      return false;
    }
    virtual void show(const char * = NULL, bool = false);
    virtual void showLabel(const char * = NULL);
    virtual void hide() = 0;
 
    virtual RES_T load(const char * /*fileName*/)
    {
      return RES_ERR_NOT_IMPLEMENTED;
    }
    virtual RES_T save(const char * /*fileName*/)
    {
      return RES_ERR_NOT_IMPLEMENTED;
    }
 
#ifndef SWIG
    virtual BaseImageViewer *getViewer() = 0;
#endif // SWIG
 
    bool updatesEnabled;
    Signal onModified;
    Signal onShow;
 
  protected:
    size_t dataTypeSize;
 
    size_t width;
    size_t height;
    size_t depth;
 
    size_t pixelCount;
    size_t lineCount;
    size_t sliceCount;
 
    bool allocated;
 
    size_t allocatedSize;
  };
 
  class ImageFreezer
  {
  public:
    ImageFreezer(BaseImage &im, bool updateOnDelete = true)
        : image(&im), update(updateOnDelete)
    {
      imState           = im.updatesEnabled;
      im.updatesEnabled = false;
    }
    ~ImageFreezer()
    {
      image->updatesEnabled = imState;
      if (update)
        image->modified();
    }
 
  protected:
    BaseImage *image;
    bool imState;
    bool update;
  };
 
#ifndef SWIG
 
  inline bool haveSameSize(const BaseImage *im, ...)
  {
    va_list vargs;
 
    va_start(vargs, im);
    if (!im->isAllocated())
      return false;
    size_t w = im->getWidth();
    size_t h = im->getHeight();
    size_t d = im->getDepth();
 
    BaseImage *obj;
    while ((obj = va_arg(vargs, BaseImage *))) {
      if (!obj->isAllocated())
        return false;
      if (obj->getWidth() != w)
        return false;
      if (obj->getHeight() != h)
        return false;
      if (obj->getDepth() != d)
        return false;
    }
    va_end(vargs);
    return true;
  }
 
  inline bool setSameSize(const BaseImage *im, ...)
  {
    if (!im->isAllocated())
      return false;
 
    va_list vargs;
 
    va_start(vargs, im);
    size_t w = im->getWidth();
    size_t h = im->getHeight();
    size_t d = im->getDepth();
 
    BaseImage *obj;
 
    while ((obj = va_arg(vargs, BaseImage *))) {
      if (obj->getWidth() != w || obj->getHeight() != h || obj->getDepth() != d)
        if (obj->setSize(w, h, d) != RES_OK)
          return false;
    }
    return true;
  }
 
  inline bool areAllocated(const BaseImage *im, ...)
  {
    va_list vargs;
 
    va_start(vargs, im);
    if (!im->isAllocated())
      return false;
 
    const BaseImage *obj;
    while ((obj = va_arg(vargs, const BaseImage *)))
      if (!obj->isAllocated())
        return false;
    va_end(vargs);
    return true;
  }
 
#define CHECK_ALLOCATED(...) (areAllocated(__VA_ARGS__, NULL))
#define ASSERT_ALLOCATED(...)                                                  \
  ASSERT(CHECK_ALLOCATED(__VA_ARGS__), RES_ERR_BAD_ALLOCATION)
 
#define CHECK_SAME_SIZE(...)                                                   \
  (Core::getInstance()->autoResizeImages ? setSameSize(__VA_ARGS__, NULL)      \
                                         : haveSameSize(__VA_ARGS__, NULL))
#define ASSERT_SAME_SIZE(...)                                                  \
  ASSERT(CHECK_SAME_SIZE(__VA_ARGS__), RES_ERR_BAD_SIZE)
 
#endif // SWIG
 
} // namespace smil
 
#endif // _DBASE_IMAGE_H