Img.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLCore/src/ICLCore/Img.h                              **
** Module : ICLCore                                                **
** Authors: Christof Elbrechter, Michael Goetting, Robert          **
**          Haschke, Andre Justus, Sergius Gaulik                  **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/SmartPtr.h>
#include <ICLUtils/Exception.h>
#include <ICLCore/ImgBase.h>
#include <ICLCore/ImgIterator.h>
#include <ICLCore/Channel.h>
#include <ICLCore/PixelRef.h>
#include <ICLMath/DynMatrix.h>
#include <cmath>
#include <algorithm>


namespace icl {
  namespace core{
    template<class Type>
    class ICLCore_API Img : public ImgBase
    {

      /* this is declare as fried, because it accesses the private append function */
      template<class ImgType> friend
      const ImgType* combineImages (const std::vector<const ImgType*>& vec, ImgBase** ppoDst);


      Img<Type>& shallowCopy(const Img<Type>& tSource);


      void append(const Img<Type> *src, int iChannel=-1);


      void append(const Img<Type> *src, const std::vector<int>& vChannels);

      protected:

      /* {{{ open */

      std::vector<utils::SmartArray<Type> > m_vecChannels;

      /* }}} */

      /* {{{ open */


      utils::SmartArray<Type> createChannel(Type *ptDataToCopy=0) const;


      int getStartIndex(int iIndex) const { return iIndex < 0 ? 0 : iIndex; }


      int getEndIndex(int iIndex) const { return iIndex < 0 ? getChannels() : iIndex+1; }


      /* }}} */

      /* {{{ open */


      void normalize(int iChannel,
                     const utils::Range<Type> &srcRange,
                     const utils::Range<Type> &dstRange);


      void mirror(axis eAxis, int iChannel,
                  const utils::Point& oOffset,
                  const utils::Size& oSize);
      /* }}} */

      public:

      static const Img<Type> null;

      /* {{{ open */

      Img(const ImgParams &params = ImgParams::null);


      Img(const utils::Size &size, int channels);


      Img(const utils::Size &s, format fmt);


      Img(const utils::Size &s, int channels, format fmt);


      Img(const utils::Size &size, format format, const std::vector<Type*>& vptData,
          bool passOwnerShip=false);


      Img(const utils::Size &size, int channels,
          const std::vector<Type*>& vptData, bool passOwnerShip=false);


      Img(const utils::Size &size, int channels, format fmt,
          const std::vector<Type*>& vptData, bool passOwnerShip=false);


      Img(const Img<Type>& tSrc);



      Img(const math::DynMatrix<Type> &c1,
          const math::DynMatrix<Type> &c2=math::DynMatrix<Type>(),
          const math::DynMatrix<Type> &c3=math::DynMatrix<Type>(),
          const math::DynMatrix<Type> &c4=math::DynMatrix<Type>(),
          const math::DynMatrix<Type> &c5=math::DynMatrix<Type>()) ;


      ~Img();

      bool isNull() const{
        return getSize()==utils::Size::null && getChannels() == 0;
      }


      /* }}} */

      /* {{{ open */

      operator Img<Type>&(){
        return *this;
      }

      operator const Img<Type>&() const {
        return *this;
      }


      Img<Type>& operator=(const Img<Type>& tSource) {
        // call private const-version
        return this->shallowCopy (static_cast<const Img<Type>&>(tSource));
      }
      /*
          #ifdef WIN32
          Img<Type>& operator=(const Img<Type>& tSource) {
          // call private const-version
          return this->shallowCopy (static_cast<const Img<Type>&>(tSource));
          }
          #endif

          #ifdef GCC_VER_423
          Img<Type>& operator=(const Img<Type>& tSource) {
          // call private const-version
          return this->shallowCopy (static_cast<const Img<Type>&>(tSource));
          }
          #endif
      */


      Type& operator()(int iX, int iY, int iChannel) {
        return const_cast<Type&>(static_cast<const Img<Type>*>(this)->operator()(iX,iY,iChannel));
      }

      const Type& operator()(int iX, int iY, int iChannel) const {
        return getData(iChannel)[iX+getWidth()*iY];
      }


      inline PixelRef<Type> operator()(int x, int y){
        return PixelRef<Type>(x,y,getWidth(),m_vecChannels);
      }

      inline const PixelRef<Type> operator()(int x, int y) const{
        return const_cast<Img<Type>*>(this)->operator()(x,y);
      }


      inline Channel<Type> operator[](int channel) {
        return Channel<Type>(begin(channel),getSize(),getROI());
      }


      inline const Channel<Type> operator[](int channel) const {
        return Channel<Type>(const_cast<Type*>(begin(channel)),getSize(),getROI());
      }


      float subPixelNN(float fX, float fY, int iChannel) const {
        return (*this)((int)fX, (int)fY, iChannel);
      }

      float subPixelLIN(float fX, float fY, int iChannel) const;

      float subPixelRA(float fX, float fY, float w, float h, int iChannel) const;
      float subPixelRA(const unsigned int xB, const unsigned int xE,
                       const unsigned int yB, const unsigned int yE,
                       const float xBMul, const float xEMul, const float BMul, const float yEMul,
                       const Type *d, const unsigned int w) const;

      Type operator()(float fX, float fY, int iChannel, scalemode eMode) const;


      /* }}} */

      /* {{{ open  */

      /*inline <Type> operator[](int channel) {
        return DynMatrix<Type>(getWidth(),getHeight(),begin(channel),false);
      }*/

      /* This function cannot be called on (0,x) or (x,0)-sized images */
      inline math::DynMatrix<Type> extractDynMatrix(int channel)
        {
        return math::DynMatrix<Type>(getWidth(),getHeight(),begin(channel),false);
      }
      /* This function cannot be called on (0,x) or (x,0)-sized images */
      inline const math::DynMatrix<Type> extractDynMatrix(int channel) const
        {
        return math::DynMatrix<Type>(getWidth(),getHeight(),const_cast<Type*>(begin(channel)),false);
      }

      inline void extractChannels(Channel<Type> *dst){
        ICLASSERT_RETURN(dst);
        for(int i=0;i<getChannels();++i){
          dst[i] = (*this)[i];
        }
      }


      inline void extractChannels(Channel<Type> *dst) const{
        (void)dst;
        ERROR_LOG("extracting channels of a const Img into an un-const Channel\n"
                  "is forbidden because it violates the const concept");
      }


      inline void extractChannels(const Channel<Type> *dst) const{
        return const_cast<Img<Type>*>(this)->extractChannels(const_cast<Channel<Type>*>(dst));
      }

      inline void extractPointers(Type **dst){
        for(int i=0;i<getChannels();++i){
          dst[i] = begin(i);
        }
      }


      inline void extractPointers(Type **dst) const{
        (void)dst;
        ERROR_LOG("extracting channel data of a const Img into an un-const pointer\n"
                  "is forbidden because it violates the const concept");
      }

      inline void extractPointers(const Type **dst) const{
        for(int i=0;i<getChannels();++i){
          dst[i] = begin(i);
        }
      }




      /* }}} */


      /* {{{ open  */

      virtual Img<Type> *shallowCopy(const utils::Rect &roi,
                                     const std::vector<int> &channelIndices,
                                     format fmt,
                                     utils::Time time = utils::Time::null,
                                     ImgBase **ppoDst = NULL);

        const Img<Type> *shallowCopy(const utils::Rect &roi,
                                     const std::vector<int> &channelIndices,
                                     format fmt,
                                     utils::Time time=utils::Time::null) const{
          // casting constness away is safe, because we effectively return a const Img<Type>*
          return const_cast<Img<Type>*>(this)->shallowCopy(roi,channelIndices,fmt,time,0);
        }



        Img<Type> *reinterpretChannels(format newFmt, Img<Type> *poDst = NULL){
           ImgBase *poDstBase = poDst;
           return shallowCopy(getROI(),std::vector<int>(),newFmt,getTime(),&poDstBase);
        }



        const Img<Type> *reinterpretChannels(format newFmt){
          return shallowCopy(getROI(),std::vector<int>(),newFmt,getTime());
        }

        Img<Type>* shallowCopy(const utils::Rect &roi,Img<Type>* poDst = NULL){
          ImgBase *poDstBase = poDst;
          return shallowCopy(roi,std::vector<int>(),getFormat(),getTime(),&poDstBase);
        }


        const Img<Type>* shallowCopy(const utils::Rect& roi) const {
           // casting constness away is safe, because we effectively return a const Img<Type>*
           return const_cast<Img<Type>*>(this)->shallowCopy(roi,0);
        }



        Img<Type>* selectChannels (const std::vector<int>& channelIndices, Img<Type>* poDst=0){
          ImgBase *poDstBase = poDst;
          return shallowCopy(getROI(),channelIndices,formatMatrix,getTime(),&poDstBase);
        }


        Img<Type> *selectChannel(int channelIndex, Img<Type> *poDst=0){
          ICLASSERT_RETURN_VAL(validChannel(channelIndex), 0);
          std::vector<int> v(1); v[0]= channelIndex;
          return selectChannels(v,poDst);
        }

        const Img<Type>* selectChannels (const std::vector<int>& channelIndices) const {
           // casting constness away is safe, because we effectively return a const Img<Type>*
           return const_cast<Img<Type>*>(this)->selectChannels(channelIndices, 0);
        }


        const Img<Type> *selectChannel(int channelIndex) const{
          ICLASSERT_RETURN_VAL(validChannel(channelIndex), 0);
          std::vector<int> v(1); v[0]= channelIndex; return selectChannels(v);
        }

        //------------------------------------------------------------------------------
        //------------------------------------------------------------------------------
        //------------------------------------------------------------------------------






      virtual Img<Type>* deepCopy(ImgBase** ppoDst=0) const;


      Img<Type> *deepCopy(Img<Type> *poDst) const;


      virtual Img<Type> *deepCopyROI(ImgBase **ppoDst=0) const;



      Img<Type> *deepCopyROI(Img<Type> *poDst) const;

      /* }}} */

      /* {{{ open */


      virtual Img<Type> *scaledCopy(const utils::Size &newSize, scalemode eScaleMode=interpolateNN) const;


      virtual Img<Type> *scaledCopy(ImgBase **ppoDst=0, scalemode eScaleMode=interpolateNN) const;



      Img<Type> *scaledCopy(Img<Type> *poDst, scalemode eScaleMode=interpolateNN) const;


      virtual Img<Type> *scaledCopyROI(const utils::Size &newSize, scalemode eScaleMode=interpolateNN) const;


      virtual Img<Type> *scaledCopyROI(ImgBase **ppoDst=0, scalemode eScaleMode=interpolateNN) const;


      Img<Type> *scaledCopyROI(Img<Type> *poDst, scalemode eScaleMode=interpolateNN) const;

      /* }}} */

      /* {{{ open */


      virtual void detach(int iIndex = -1);


      inline Img<Type> detached() const {
        Img<Type> detachedCopy = *this;
        detachedCopy.detach();
        return detachedCopy;
      }


      virtual void removeChannel(int iChannel);


      void append(Img<Type> *src, int iChannel=-1) {
        // call private const-version
        this->append (static_cast<const Img<Type>*>(src), iChannel);
      }


      void append(Img<Type> *src, const std::vector<int>& vChannels) {
        // call private const-version
        this->append (static_cast<const Img<Type>*>(src), vChannels);
      }


      Img<Type> extractChannelImg(int index);


      const Img<Type> extractChannelImg(int index) const;


      Img<Type> extractChannelImg(const std::vector<int> &indices);


      const Img<Type> extractChannelImg(const std::vector<int> &indices) const;



      virtual void swapChannels(int iIndexA, int iIndexB);


      void replaceChannel(int iThisIndex, Img<Type> *poOtherImg, int iOtherIndex);


      virtual void setChannels(int iNewNumChannels);


      virtual void setSize(const utils::Size &s);


      /* }}} */

      /* {{{ open */


      Type getMax(int iChannel, utils::Point *coords=0) const;


      Type getMin(int iChannel, utils::Point *coords=0) const;


      Type getMin() const;

      Type getMax() const;


      const utils::Range<Type> getMinMax(int iChannel,
                                         utils::Point *minCoords=0,
                                         utils::Point *maxCoords=0) const;

      const utils::Range<Type> getMinMax() const;


      virtual int getLineStep() const{
        return getSize().width*sizeof(Type);
      }


      Type* getData(int iChannel) {
        return const_cast<Type*>(static_cast<const Img<Type>*>(this)->getData(iChannel));
      }


      const Type* getData(int iChannel) const {
        FUNCTION_LOG("");
        ICLASSERT_RETURN_VAL(validChannel(iChannel), 0);
        return m_vecChannels[iChannel].get();
      }


      Type* getROIData(int iChannel) {
        return const_cast<Type*>(static_cast<const Img<Type>*>(this)->getROIData(iChannel));
      }


      const Type* getROIData(int iChannel) const {
        FUNCTION_LOG("");
        ICLASSERT_RETURN_VAL(validChannel(iChannel),0);
        return getData(iChannel) + m_oParams.getPixelOffset();
      }


      Type* getROIData(int iChannel, const utils::Point &p) {
        return const_cast<Type*>(static_cast<const Img<Type>*>(this)->getROIData(iChannel, p));
      }

      const Type* getROIData(int iChannel, const utils::Point &p) const {
        FUNCTION_LOG("");
        ICLASSERT_RETURN_VAL(validChannel(iChannel),0);
        return getData(iChannel) + p.x + (p.y * getWidth());
      }


      virtual void* getDataPtr(int iChannel){
        return getData(iChannel);
      }


      virtual const void* getDataPtr(int iChannel) const{
        return getData(iChannel);
      }


      /* }}} */

      /* {{{ open */



      template<typename UnaryFunction>
      inline Img<Type> &forEach_C(UnaryFunction f, int channel){
        ICLASSERT_RETURN_VAL(validChannel(channel),*this);
        if(hasFullROI()){
          std::for_each<Type*,UnaryFunction>(getData(channel),getData(channel)+getDim(),f);
        }else{
          const_roi_iterator end = endROI(channel);
          for(ImgIterator<Type> it = beginROI(channel); it != end; it.incRow()){
            std::for_each<Type*,UnaryFunction>(&(*it),&(*it)+it.getSubRectWidth(),f);
          }
        }
        return *this;
      }


      template<typename UnaryFunction>
      inline Img<Type> &forEach(UnaryFunction f){
        for(int c=0;c<getChannels();++c){
          forEach_C(f,c);
        }
        return *this;
      }


      template<typename UnaryFunction, class dstType>
      inline Img<dstType> &transform_C(UnaryFunction f, int srcChannel, int dstChannel, Img<dstType> &dst) const{
        ICLASSERT_RETURN_VAL(getROISize() == dst.getROISize(),dst);
        ICLASSERT_RETURN_VAL(validChannel(srcChannel),dst);
        ICLASSERT_RETURN_VAL(dst.validChannel(dstChannel),dst);

        if(hasFullROI() && dst.hasFullROI()){
          std::transform(getData(srcChannel),getData(srcChannel)+getDim(),dst.getData(dstChannel),f);
        }else{
          ImgIterator<dstType> itDst = dst.beginROI(dstChannel);
          const_roi_iterator end = endROI(srcChannel);
          for(const_roi_iterator it = beginROI(srcChannel); it != end; it.incRow(), itDst.incRow()){
            std::transform(&(*it),&(*it)+it.getSubRectWidth(),&(*itDst),f);
          }
        }
        return dst;
      }


      template<typename UnaryFunction,class dstType>
      inline Img<dstType> &transform(UnaryFunction f, Img<dstType> &dst) const{
        ICLASSERT_RETURN_VAL(getChannels() == dst.getChannels(),dst);
        for(int c=0;c<getChannels();++c){
          transform_C(f,c,c,dst);
        }
        return dst;
      }



      template<typename BinaryFunction, class dstType, class otherSrcType>
      inline Img<dstType> &combine_C(BinaryFunction f,
                                     int thisChannel,
                                     int otherSrcChannel,
                                     int dstChannel,
                                     const Img<otherSrcType> &otherSrc,
                                     Img<dstType> &dst) const{
        ICLASSERT_RETURN_VAL(getROISize() == dst.getROISize()&& getROISize() == otherSrc.getROISize(),dst);
        ICLASSERT_RETURN_VAL(validChannel(thisChannel),dst);
        ICLASSERT_RETURN_VAL(otherSrc.validChannel(otherSrcChannel),dst);
        ICLASSERT_RETURN_VAL(dst.validChannel(dstChannel),dst);

        if(hasFullROI() && dst.hasFullROI() && otherSrc.hasFullROI()){
          std::transform(getData(thisChannel),getData(thisChannel)+getDim(),otherSrc.getData(otherSrcChannel),dst.getData(dstChannel),f);
        }else{
          ImgIterator<dstType> itDst = dst.beginROI(dstChannel);
          const ImgIterator<otherSrcType> itOtherSrc = otherSrc.beginROI(otherSrcChannel);
          const_roi_iterator end = endROI(thisChannel);
          for(const_roi_iterator it = beginROI(thisChannel); it!=end; it.incRow(), itDst.incRow(),itOtherSrc.incRow()){
            std::transform(&(*it),&(*it)+it.getROIWidth(),&(*itOtherSrc),&(*itDst),f);
          }
        }
        return dst;
      }



      template<typename BinaryFunction, class dstType, class otherSrcType>
      inline Img<dstType> &combine(BinaryFunction f, const Img<otherSrcType> &otherSrc, Img<dstType> &dst) const{
        ICLASSERT_RETURN_VAL(getChannels() == otherSrc.getChannels(),dst);
        ICLASSERT_RETURN_VAL(getChannels() == dst.getChannels(),dst);
        for(int c=0;c<getChannels();++c){
          combine_C(f,c,c,c,otherSrc,dst);
        }
        return dst;
      }



      private:
      template<typename Tsrc, typename Tdst, int Nsrc, int Ndst, typename ReduceFunc>
      static inline void reduce_arrays(const Tsrc *src[Nsrc], Tdst *dst[Ndst], unsigned int dim, ReduceFunc reduce){
        for(int i=dim-1;i>=0;--i){
          Tsrc tsrc[Nsrc];
          Tdst tdst[Ndst];
          for(int j=0;j<Nsrc;tsrc[j]=src[j][i],++j) {}
          reduce(tsrc,tdst);
          for(int j=0;j<Ndst;dst[j][i]=tdst[j],++j) {}

        }
      }

      public:



      template<typename Tdst, int Nthis, int Ndst, typename ReduceFunc>
      void reduce_channels(Img<Tdst> &dst, ReduceFunc reduce) const {
        ICLASSERT_RETURN(this->getROISize() == dst.getROISize());
        ICLASSERT_RETURN((Nthis > 0) && (Ndst > 0));
        ICLASSERT_RETURN((this->getChannels()==Nthis) &&  (dst.getChannels()==Ndst));

        const Type *psrc[Nthis];
        Tdst *pdst[Ndst];
        if(this->hasFullROI() && dst.hasFullROI()){
          for(int i=0;i<Nthis;psrc[i]=this->getData(i),++i) {}
          for(int i=0;i<Ndst;pdst[i]=dst.getData(i),++i) {}
          reduce_arrays<Type,Tdst,Nthis,Ndst,ReduceFunc>(psrc,pdst,this->getDim(),reduce);
        }else{
          const_roi_iterator itSrc[Nthis];
          ImgIterator<Tdst> itDst[Ndst];
          for(int i=0;i<Nthis;itSrc[i]=this->beginROI(i),++i) {}
          for(int i=0;i<Ndst;itDst[i]=dst.beginROI(i),++i) {}

          for(int l=this->getROI().height-1, w=this->getROI().width ;l>=0;--l){
            for(int i=0;i<Nthis;itSrc[i].incRow(),++i){
              psrc[i]=&(*(itSrc[i]));
            }
            for(int i=0;i<Ndst;itDst[i].incRow(),++i){
              pdst[i]=&(*(itDst[i]));
            }
            reduce_arrays<Type,Tdst,Nthis,Ndst,ReduceFunc>(psrc,pdst,w,reduce);
          }
        }
      }


      Img<Type> *lut(const Type *lut, Img<Type> *dst = 0,int bits=8) const;


      virtual void scale(const utils::Size &s, scalemode eScaleMode=interpolateNN);


      virtual void mirror(axis eAxis, bool bOnlyROI=false);


      void clear(int iChannel = -1, Type tValue = 0, bool bROIOnly=true);


      template<class T>
      inline void fill(const T &value){
        for(int i=0;i<getChannels();++i){
          std::fill(begin(i),end(i),value);
        }
      }

      template<class T>
      inline void fillChannel(int channel, const T &value){
        std::fill(begin(channel),end(channel),value);
      }


      template<class T>
      inline void fillROI(const T &value){
        for(int i=0;i<getChannels();++i){
          std::fill(beginROI(i),endROI(i),value);
        }
      }

      template<class T>
      inline void fillChannelROI(int channel, const T &value){
        std::fill(beginROI(channel),endROI(channel),value);
      }



      void normalizeAllChannels(const utils::Range<Type> &dstRange);


      void normalizeChannel(int iChannel, const utils::Range<Type> &srcRange,
                            const utils::Range<Type> &dstRange);


      void normalizeChannel(int iChannel,const utils::Range<Type> &dstRange);


      void normalizeImg(const utils::Range<Type> &srcRange,
                        const utils::Range<Type> &dstRange);


      void normalizeImg(const utils::Range<Type> &dstRange);


      /* }}} */

      /* {{{ open */

      typedef Type* iterator;

      typedef const Type* const_iterator;

      typedef ImgIterator<Type> roi_iterator;

      typedef const ImgIterator<Type> const_roi_iterator;
      // old    typedef constConstImgIterator<Type> const_iterator;



      inline iterator begin(int channel){
        return getData(channel);
      }

      inline const_iterator begin(int channel) const{
        return const_cast<Img<Type>*>(this)->begin(channel);
      }

      iterator end(int channel){
        return getData(channel)+getDim();
      }

      const_iterator end(int channel) const{
        return getData(channel)+getDim();
      }

      inline roi_iterator beginROI(int channel){
        ICLASSERT_RETURN_VAL(validChannel(channel), roi_iterator());
        return roi_iterator(getData(channel),getWidth(),getROI());
      }

      inline const_roi_iterator beginROI(int channel) const{
        ICLASSERT_RETURN_VAL(validChannel(channel), roi_iterator());
        return const_cast<Img<Type>*>(this)->beginROI(channel);
      }


      inline roi_iterator endROI(int channel) {
        ICLASSERT_RETURN_VAL(validChannel(channel), roi_iterator());
        return roi_iterator::create_end_roi_iterator(getData(channel),getWidth(),getROI());
      }

      inline const_roi_iterator endROI(int channel) const{
        ICLASSERT_RETURN_VAL(validChannel(channel), roi_iterator());
        return const_roi_iterator::create_end_roi_iterator(getData(channel),getWidth(),getROI());
      }



      utils::Point getLocation(const Type *p, int channel, bool relToROI=false) const;


      void printAsMatrix(const std::string &format="5.3", bool visROI=true) const;


      virtual bool isIndependent() const;

      /* }}} */

      /* {{{ open */


      virtual void fillBorder(bool setFullROI=true);

      virtual void fillBorder(icl64f val, bool setFullROI=true);


      virtual void fillBorder(const std::vector<icl64f> &vals, bool setFullROI=true);



      virtual void fillBorder(const ImgBase *src, bool setFullROI=true);

      /* }}} */


    };// class Img<Type>


    /* {{{ global functions */


    template<class T> struct ICLCore_API ImgBasePtrPtr {
      ImgBasePtrPtr(Img<T> &i);

      ImgBasePtrPtr(Img<T> *i);


      ~ImgBasePtrPtr();

      operator ImgBase** (){ return &r; }

      private:
      ImgBase *o,*r,*rbef;
    };


    template<class T>
    ImgBasePtrPtr<T> bpp(Img<T> *image) { return ImgBasePtrPtr<T>(image); }


    template<class T>
    ImgBasePtrPtr<T> bpp(Img<T> &image) { return ImgBasePtrPtr<T>(image); }



    template<class T>
    static inline T p2o(T *ptr){
      return *utils::SmartPtr<T>(ptr);
    }

    template<class ImgType>
    const ImgType* combineImages(const std::vector<const ImgType*>& vec);

    template<class ImgType>
    ImgType* combineImages(const std::vector<ImgType*>& vec) {
      return const_cast<ImgType*>(combineImages(reinterpret_cast<const std::vector<const ImgType*>&>(vec)));
    }

    /* {{{   deepCopyChannel */
    template<class T>
    inline void deepCopyChannel(const Img<T> *src, int srcC, Img<T> *dst, int dstC){
      FUNCTION_LOG("");
      ICLASSERT_RETURN( src && dst );
      ICLASSERT_RETURN( src->getSize() == dst->getSize() );
      ICLASSERT_RETURN( src->validChannel(srcC) );
      ICLASSERT_RETURN( dst->validChannel(dstC) );
      icl::core::copy<T>(src->getData(srcC),src->getData(srcC)+src->getDim(),dst->getData(dstC));
    }

    /* }}} */

    /* {{{   convertChannel */


    template<class S,class D>
    inline void convertChannel(const Img<S> *src, int srcC, Img<D> *dst, int dstC){
      FUNCTION_LOG("");
      ICLASSERT_RETURN( src && dst );
      ICLASSERT_RETURN( src->getSize() == dst->getSize() );
      ICLASSERT_RETURN( src->validChannel(srcC) );
      ICLASSERT_RETURN( dst->validChannel(dstC) );
      icl::core::convert<S,D>(src->getData(srcC),src->getData(srcC)+src->getDim(),dst->getData(dstC));
    }

    /* }}} */

    /* {{{   clearChannelROI */


    template<class T>
    inline void clearChannelROI(Img<T> *im, int c, T clearVal, const utils::Point &offs,
                                const utils::Size &size) {
      FUNCTION_LOG("");
      ICLASSERT_RETURN( im );

      ImgIterator<T> it(im->getData(c),im->getSize().width,utils::Rect(offs,size));
      const ImgIterator<T> itEnd = ImgIterator<T>::create_end_roi_iterator(im->getData(c),
                                                                           im->getWidth(),
                                                                           utils::Rect(offs,size));
      std::fill(it,itEnd,clearVal);
    }

#ifdef ICL_HAVE_IPP
    template <>
    inline void clearChannelROI(Img<icl8u> *im, int c, icl8u clearVal, const utils::Point &offs,
                                const utils::Size &size){
      FUNCTION_LOG("");
      ICLASSERT_RETURN( im );
      ippiSet_8u_C1R(clearVal,im->getROIData(c,offs),im->getLineStep(),size);
    }
    template <>
    inline void clearChannelROI(Img<icl16s> *im, int c, icl16s clearVal, const utils::Point &offs,
                                const utils::Size &size){
      FUNCTION_LOG("");
      ICLASSERT_RETURN( im );
      ippiSet_16s_C1R(clearVal,im->getROIData(c,offs),im->getLineStep(),size);
    }
    template <>
    inline void clearChannelROI(Img<icl32s> *im, int c, icl32s clearVal,
                                const utils::Point &offs, const utils::Size &size){
      FUNCTION_LOG("");
      ICLASSERT_RETURN( im );
      ippiSet_32s_C1R(clearVal,im->getROIData(c,offs),im->getLineStep(),size);
    }
    template <>
    inline void clearChannelROI(Img<icl32f> *im, int c, icl32f clearVal,
                                const utils::Point &offs, const utils::Size &size){
      FUNCTION_LOG("");
      ICLASSERT_RETURN( im );
      ippiSet_32f_C1R(clearVal,im->getROIData(c,offs),im->getLineStep(),size);
    }
#endif

    /* }}} */

#define CHECK_VALUES(src,srcC,srcOffs,srcSize,dst,dstC,dstOffs,dstSize) \
    FUNCTION_LOG("");                                                   \
    ICLASSERT_RETURN( src && dst );                                     \
    ICLASSERT_RETURN( srcSize == dstSize );                             \
    ICLASSERT_RETURN( src->validChannel(srcC) );                        \
    ICLASSERT_RETURN( dst->validChannel(dstC) );                        \
    ICLASSERT_RETURN( srcOffs.x >= 0 && srcOffs.y >= 0 && dstOffs.x >= 0 && dstOffs.y >= 0); \
    ICLASSERT_RETURN( srcOffs.x+srcSize.width <= src->getWidth() && srcOffs.y+srcSize.height <= src->getHeight() ); \
    ICLASSERT_RETURN( dstOffs.x+dstSize.width <= dst->getWidth() && dstOffs.y+dstSize.height <= dst->getHeight() );

    /* {{{   deepCopyChannelROI */


    template <class T>
    inline void deepCopyChannelROI(const Img<T> *src, int srcC, const utils::Point &srcOffs,
                                   const utils::Size &srcSize,
                                   Img<T> *dst,int dstC, const utils::Point &dstOffs,
                                   const utils::Size &dstSize) {
      CHECK_VALUES(src,srcC,srcOffs,srcSize,dst,dstC,dstOffs,dstSize);

      const ImgIterator<T> itSrc(const_cast<T*>(src->getData(srcC)),
                                 src->getSize().width,
                                 utils::Rect(srcOffs,srcSize));
      ImgIterator<T> itDst(dst->getData(dstC),dst->getSize().width,utils::Rect(dstOffs,dstSize));
      const ImgIterator<T> itSrcEnd = ImgIterator<T>::create_end_roi_iterator(src->getData(srcC),
                                                                              src->getWidth(),
                                                                              utils::Rect(srcOffs,srcSize));

      for(;itSrc != itSrcEnd;itSrc.incRow(),itDst.incRow()){
        icl::core::copy<T>(&*itSrc,&*itSrc+srcSize.width,&*itDst);
      }
    }

    /* }}} */

    /* {{{   convertChannelROI */


    template <class S,class D>
    inline void convertChannelROI(const Img<S> *src, int srcC, const utils::Point &srcOffs,
                                  const utils::Size &srcROISize,
                                  Img<D> *dst,int dstC, const utils::Point &dstOffs,
                                  const utils::Size &dstROISize)
    {
      FUNCTION_LOG("");
      CHECK_VALUES(src,srcC,srcOffs,srcROISize,dst,dstC,dstOffs,dstROISize);

      const ImgIterator<S> itSrc(const_cast<S*>(src->getData(srcC)),
                                 src->getSize().width,
                                 utils::Rect(srcOffs,srcROISize));
      ImgIterator<D> itDst(dst->getData(dstC),dst->getSize().width,
                           utils::Rect(dstOffs,dstROISize));
      const ImgIterator<S> itSrcEnd = ImgIterator<S>::create_end_roi_iterator(src->getData(srcC),
                                                                              src->getWidth(),
                                                                              utils::Rect(srcOffs,srcROISize));
      for(;itSrc != itSrcEnd ;itSrc.incRow(),itDst.incRow()){
        icl::core::convert<S,D>(&*itSrc,&*itSrc+srcROISize.width,&*itDst);
      }
    }


    /* }}} */

    /* {{{   scaledCopyChannelROI */


    template<class T> ICLCore_API
    void scaledCopyChannelROI(const Img<T> *src, int srcC,
                              const utils::Point &srcOffs,
                              const utils::Size &srcSize,
                              Img<T> *dst,int dstC,
                              const utils::Point &dstOffs,
                              const utils::Size &dstSize,
                              scalemode eScaleMode);

    /* }}} */

    /* {{{   flippedCopyChannelROI */


    template <class T> ICLCore_API
    void flippedCopyChannelROI(axis eAxis,
                               const Img<T> *src,int srcC, const utils::Point &srcOffs,
                               const utils::Size &srcSize,
                               Img<T> *dst,int dstC, const utils::Point &dstOffs,
                               const utils::Size &dstSize);



    ICLCore_API void flippedCopy(axis eAxis, const ImgBase *poSrc, ImgBase **ppoDst = 0);


    ICLCore_API void flippedCopyROI(axis eAxis, const ImgBase *poSrc, ImgBase **ppoDst = 0);
    /* }}} */

    /* }}} */
  } // namespace core
} //namespace icl

#undef CHECK_VALUES