DImage.hpp

/*
 * 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 _DIMAGE_HPP
#define _DIMAGE_HPP
 
#include <string>
 
#include "Core/include/DBaseImage.h"
#include "Gui/include/DBaseImageViewer.h"
 
namespace smil
{
  template <class T> class ImageViewer;
 
  template <class T> class ResImage;
 
  template <class T> class SharedImage;
 
  template <class T> class Image : public BaseImage
  {
    typedef BaseImage parentClass;
 
  public:
    Image();
    Image(size_t w, size_t h, size_t d = 1);
    Image(const char *fileName);
 
    virtual ~Image();
 
    // Provide explicit copy constructor and assignment operator
    Image(const Image<T> &rhs, bool cloneData = false);
 
    template <class T2> Image(const Image<T2> &rhs, bool cloneData = false);
    Image(const ResImage<T> &rhs, bool cloneData = true);
 
    // Assignment operator
    Image<T> &operator=(const Image<T> &rhs)
    {
      this->clone(rhs);
      return *this;
    }
 
    Image(BaseImage *_im, bool stealIdentity = false);
 
    // SWIG-Python doesn't handle abstract classes.
    // Usefull when creating an image from createFromFile (kind of cast).
    void drain(Image<T> *im, bool deleteSrc = false);
 
    virtual const char *getTypeAsString()
    {
      T *dum = NULL;
      return getDataTypeAsString<T>(dum);
    }
    typedef typename ImDtTypes<T>::pixelType pixelType;
    typedef typename ImDtTypes<T>::lineType lineType;
    typedef typename ImDtTypes<T>::restrictLineType restrictLineType;
    typedef typename ImDtTypes<T>::sliceType sliceType;
    typedef typename ImDtTypes<T>::volType volType;
 
    lineType getPixels() const
    {
      return pixels;
    }
 
    sliceType getLines() const
    {
      return lines;
    }
 
    volType getSlices() const
    {
      return slices;
    }
 
    SharedImage<T> getSlice(size_t sliceNum) const;
 
    inline T getPixel(size_t x, size_t y, size_t z = 0) const
    {
      ASSERT((x < width && y < height && z < depth),
             "Coords out of image range", T(0));
      return pixels[z * width * height + y * width + x];
    }
 
    inline T getPixel(size_t offset) const
    {
      ASSERT((offset < pixelCount), "Offset out of image range", T(0));
      return pixels[offset];
    }
 
    inline T getPixelNoCheck(size_t offset) const
    {
      return pixels[offset];
    }
 
    inline RES_T setPixel(size_t x, size_t y, size_t z, const T &value)
    {
      ASSERT((x < width && y < height && z < depth),
             "Coords out of image range", RES_ERR);
      pixels[z * width * height + y * width + x] = value;
      modified();
      return RES_OK;
    }
 
    inline RES_T setPixel(size_t x, size_t y, const T &value)
    {
      return setPixel(x, y, 0, value);
    }
 
    inline RES_T setPixel(size_t offset, const T &value)
    {
      ASSERT((offset < pixelCount), "Offset out of image range", RES_ERR);
      pixels[offset] = value;
      modified();
      return RES_OK;
    }
 
    inline void setPixelNoCheck(size_t offset, const T &value)
    {
      pixels[offset] = value;
    }
 
    void toArray(T outArray[]);
 
    void fromArray(const T inArray[]);
 
    void toCharArray(signed char outArray[]);
    char *toCharArray()
    {
      return (char *) pixels;
    }
    void fromCharArray(const signed char inArray[]);
 
    void toIntArray(int outArray[]);
 
    void fromIntArray(const int inArray[]);
 
    vector<int> toIntVector();
 
    void fromIntVector(const vector<int> inVector);
 
    string toString();
    void fromString(string pixVals);
 
    virtual ImageViewer<T> *getViewer();
 
    virtual bool isVisible();
 
    virtual void init();
 
    virtual void clone(const Image<T> &rhs);
    template <class T2> void clone(const Image<T2> &rhs);
    virtual Image<T> clone(bool cloneData = true)
    {
      Image<T> im(*this, cloneData);
      return im;
    }
 
    virtual RES_T setSize(size_t w, size_t h, size_t d = 1,
                          bool doAllocate = true);
    virtual RES_T setSize(size_t s[3], bool doAllocate = true)
    {
      return setSize(s[0], s[1], s[2], doAllocate);
    }
    virtual RES_T setSize(const BaseImage &rhs, bool doAllocate = true)
    {
      return setSize(rhs.getWidth(), rhs.getHeight(), rhs.getDepth(),
                     doAllocate);
    }
    virtual RES_T setSize(const vector<UINT> s, bool doAllocate = true)
    {
      if (s.size() == 3)
        return setSize(s[0], s[1], s[2], doAllocate);
      else
        return setSize(s[0], s[1], 1, doAllocate);
    }
 
    virtual RES_T allocate();
    virtual RES_T deallocate();
 
    void printSelf(ostream &os, bool displayPixVals, bool hexaGrid = false,
                   string indent = "") const;
 
    virtual void printSelf(ostream &os = std::cout, string indent = "") const
    {
      printSelf(os, false, false, indent);
    }
 
    virtual void printSelf(string indent)
    {
      printSelf(std::cout, false, false, indent);
    }
 
    void printSelf(bool displayPixVals, bool hexaGrid = false, string indent = "")
    {
      printSelf(std::cout, displayPixVals, hexaGrid, indent);
    }
 
    virtual const char *getInfoString(const char *indent = "") const
    {
      stringstream s;
      this->printSelf(s, indent);
      return s.str().c_str();
    }
 
    virtual void *getVoidPointer(void)
    {
      return pixels;
    }
 
    virtual RES_T load(const char *fileName);
    virtual RES_T save(const char *fileName);
 
#if defined SWIGPYTHON && defined USE_NUMPY
    PyObject *getNumArray(bool c_contigous = false);
 
    void fromNumArray(PyObject *array);
#endif // defined SWIGPYTHON && defined USE_NUMPY
 
    virtual void modified();
 
    static T getDataTypeMin()
    {
      return ImDtTypes<T>::min();
    }
 
    static T getDataTypeMax()
    {
      return ImDtTypes<T>::max();
    }
 
    inline T &operator[](size_t i)
    {
      if (i < pixelCount)
        return this->pixels[i];
      ERR_MSG("Offset out of range.");
      return this->dumPixel;
    }
 
    Image<T> &operator<<(const Image<T> &rhs);
    Image<T> &operator<<(const T &value);
    ResImage<T> operator~() const;
    ResImage<T> operator-() const;
    ResImage<T> operator+(const Image<T> &rhs);
    ResImage<T> operator+(const T &value);
    Image<T> &operator+=(const Image<T> &rhs);
    Image<T> &operator+=(const T &value);
    ResImage<T> operator-(const Image<T> &rhs);
    ResImage<T> operator-(const T &value);
    Image<T> &operator-=(const Image<T> &rhs);
    Image<T> &operator-=(const T &value);
    ResImage<T> operator*(const Image<T> &rhs);
    ResImage<T> operator*(const T &value);
    Image<T> &operator*=(const Image<T> &rhs);
    Image<T> &operator*=(const T &value);
    ResImage<T> operator/(const Image<T> &rhs);
    ResImage<T> operator/(const T &value);
    Image<T> &operator/=(const Image<T> &rhs);
    Image<T> &operator/=(const T &value);
    ResImage<T> operator==(const Image<T> &rhs);
    ResImage<T> operator!=(const Image<T> &rhs);
    ResImage<T> operator<(const Image<T> &rhs);
    ResImage<T> operator<(const T &value);
    ResImage<T> operator<=(const Image<T> &rhs);
    ResImage<T> operator<=(const T &value);
    ResImage<T> operator>(const Image<T> &rhs);
    ResImage<T> operator>(const T &value);
    ResImage<T> operator>=(const Image<T> &rhs);
    ResImage<T> operator>=(const T &value);
 
    ResImage<T> operator|(const Image<T> &rhs);
    ResImage<T> operator|(const T &value);
    Image<T> &operator|=(const Image<T> &rhs);
    Image<T> &operator|=(const T &value);
 
    ResImage<T> operator&(const Image<T> &rhs);
    ResImage<T> operator&(const T &value);
    Image<T> &operator&=(const Image<T> &rhs);
    Image<T> &operator&=(const T &value);
 
    operator bool();
 
    Image<T> &operator<<(const lineType &tab);
    Image<T> &operator<<(vector<T> &vect);
    Image<T> &operator>>(vector<T> &vect);
 
#ifndef SWIG
    Image<T> &operator<<(const char *s);
#endif // SWIG
    inline Image<T> &operator<<(const string s)
    {
      return this->operator<<(s.c_str());
    }
 
    Image<T> &operator>>(const char *s);
    inline Image<T> &operator>>(const string s)
    {
      return this->operator>>(s.c_str());
    }
 
  protected:
    lineType pixels;
    sliceType lines;
    volType slices;
 
    RES_T restruct(void);
 
    ImageViewer<T> *viewer;
    void createViewer();
 
    T dumPixel;
    // Specify if the viewer has been created internally
    //     ImageViewerWidget *viewer;
 
  public:
    virtual void setName(const char *_name);
 
    virtual void show(const char *_name = NULL, bool labelImage = false);
 
    virtual void showLabel(const char *_name = NULL);
 
    virtual void showNormal(const char *_name = NULL);
 
    virtual void hide();
  };
 
  template <class T> class ResImage : public Image<T>
  {
  public:
    ResImage(const Image<T> &rhs) : Image<T>(rhs, false)
    {
    }
 
    // Warning ! This will empty the image rhs !
    // Allows to avoid multiple copy with SwigValueWrapper operations...
    ResImage(const ResImage<T> &rhs) : Image<T>()
    {
      Image<T>::drain(const_cast<ResImage<T> *>(&rhs));
    }
 
    ~ResImage()
    {
    }
  };
 
  template <class T> Image<T> *createImage(const T)
  {
    return new Image<T>();
  }
 
  template <class T> Image<T> *castBaseImage(BaseImage *img, const T &)
  {
    ASSERT(strcmp(getDataTypeAsString<T>(), img->getTypeAsString()) == 0,
           "Bad type for cast", NULL);
    return reinterpret_cast<Image<T> *>(img);
  }
 
  template <class T>
  RES_T drawOverlay(const Image<T> &imToDraw, Image<T> &imOut)
  {
    imOut.getViewer()->drawOverlay(imToDraw);
    return RES_OK;
  }
 
} // namespace smil
 
#endif // _DIMAGE_HPP