ImgBase.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/ImgBase.h                          **
** Module : ICLCore                                                **
** Authors: Christof Elbrechter, Michael Goetting, Robert          **
**          Haschke, Andre Justus                                  **
**                                                                 **
**                                                                 **
** 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/CompatMacros.h>
#include <ICLCore/CoreFunctions.h>
#include <ICLCore/ImgParams.h>
#include <ICLUtils/Time.h>
#include <ICLUtils/Range.h>
#include <ICLUtils/SmartPtr.h>
#include <vector>
#include <string>

namespace icl {
  namespace core{


    class ICLCore_API ImgBase{
      public:

      virtual ~ImgBase();

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

      const ImgBase *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<ImgBase*>(this)->shallowCopy(roi,channelIndices,fmt,time,0);
      }



      ImgBase *reinterpretChannels(format newFmt, ImgBase **ppoDst = NULL){
        return shallowCopy(getROI(),std::vector<int>(),newFmt,getTime(),ppoDst);
      }



      const ImgBase *reinterpretChannels(format newFmt) const{
        // casting constness away is safe, because we effectively return a const Img<Type>*
        return const_cast<ImgBase*>(this)->shallowCopy(getROI(),std::vector<int>(),newFmt,getTime());
      }

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


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



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


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

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


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


      virtual ImgBase *deepCopy(ImgBase **ppoDst=0) const=0;


      virtual ImgBase *deepCopyROI(ImgBase **ppoDst=0) const=0;


      template<class T> ICLCore_API
      Img<T> *convert(Img<T> *poDst=NULL) const;


      ImgBase *convert(depth d) const;


      ImgBase *convert(ImgBase *poDst) const;


      template<class T> ICLCore_API
      Img<T> *convertROI(Img<T> *poDst=NULL) const;


      ImgBase *convertROI(depth d) const;



      ImgBase *convertROI(ImgBase *poDst) const;


      virtual ImgBase *scaledCopy(const utils::Size &newSize,
                                  scalemode eScaleMode=interpolateNN) const = 0;


      virtual ImgBase *scaledCopy(ImgBase **ppoDst=0,
                                  scalemode eScaleMode=interpolateNN) const = 0;


      virtual ImgBase *scaledCopyROI(const utils::Size &newSize,
                                     scalemode eScaleMode=interpolateNN) const = 0;


      virtual ImgBase *scaledCopyROI(ImgBase **ppoDst=0,
                                     scalemode eScaleMode=interpolateNN) const = 0;



      template <class T>
      Img<T> *asImg() {
        ICLASSERT_RETURN_VAL( icl::core::getDepth<T>() == this->getDepth(), 0);
        return reinterpret_cast<Img<T>*>(this);
      }


      template <class T>
      const Img<T> *asImg() const {
        ICLASSERT_RETURN_VAL( icl::core::getDepth<T>() == getDepth(), 0);
        return reinterpret_cast<const Img<T>*>(this);
      }

      inline Img<icl8u> *as8u() { return asImg<icl8u>(); }

      inline Img<icl16s> *as16s() { return asImg<icl16s>(); }

      inline Img<icl32s> *as32s() { return asImg<icl32s>(); }

      inline Img<icl32f> *as32f() { return asImg<icl32f>(); }

      inline Img<icl64f> *as64f() { return asImg<icl64f>(); }


      inline const Img<icl8u> *as8u() const { return asImg<icl8u>(); }

      inline const Img<icl16s> *as16s() const { return asImg<icl16s>(); }

      inline const Img<icl32s> *as32s() const { return asImg<icl32s>(); }

      inline const Img<icl32f> *as32f() const { return asImg<icl32f>(); }

      inline const Img<icl64f> *as64f() const { return asImg<icl64f>(); }



      const ImgParams &getParams() const{ return m_oParams; }

      // returns the images size
      const utils::Size& getSize() const { return m_oParams.getSize(); }

      int getWidth() const { return m_oParams.getWidth(); }

      int getHeight() const { return m_oParams.getHeight(); }

      int getDim() const { return m_oParams.getDim(); }

      int getChannels() const { return m_oParams.getChannels(); }

      depth getDepth() const { return m_eDepth; }

      format getFormat() const { return m_oParams.getFormat(); }

      utils::Time getTime() const { return m_timestamp; }


      virtual int getLineStep() const = 0;




      const utils::Rect &getROI() const{ return m_oParams.getROI(); }

      void getROI(utils::Point& offset, utils::Size& size) const { m_oParams.getROI(offset,size); }

      utils::Point getROIOffset() const{ return m_oParams.getROIOffset(); }

      utils::Size getROISize() const{ return m_oParams.getROISize(); }

      int getROIWidth() const{ return m_oParams.getROIWidth(); }

      int getROIHeight() const{ return m_oParams.getROIHeight(); }

      int getROIXOffset() const{ return m_oParams.getROIXOffset(); }

      int getROIYOffset() const{ return m_oParams.getROIYOffset(); }

      utils::Rect getImageRect() const { return utils::Rect(utils::Point::null,getSize()); }

      void setROIOffset(const utils::Point &offset) { m_oParams.setROIOffset(offset); }

      void setROISize(const utils::Size &size) { m_oParams.setROISize(size); }

      void setROI(const utils::Point &offset, const utils::Size &size){ m_oParams.setROI(offset,size); }

      void setROI(const utils::Rect &roi) { m_oParams.setROI(roi); }


      void setROIOffsetAdaptive(const utils::Point &offset) { m_oParams.setROIOffsetAdaptive(offset); }


      void setROISizeAdaptive(const utils::Size &size){ m_oParams.setROISizeAdaptive(size); }


      void setROIAdaptive(const utils::Rect &roi) { m_oParams.setROIAdaptive(roi); }

      int hasFullROI() const { return m_oParams.hasFullROI(); }

      void setFullROI() { m_oParams.setFullROI(); }




      virtual void fillBorder(bool setFullROI=true)=0;

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


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



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



      virtual const void* getDataPtr(int iChannel) const = 0;


      virtual void* getDataPtr(int iChannel) = 0;




      virtual void detach(int iIndex = -1)=0;


      virtual void removeChannel(int iChannel)=0;


      virtual void swapChannels(int iIndexA, int iIndexB)=0;


      void setParams(const ImgParams &params);


      virtual void setChannels(int iNewNumChannels)=0;


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


      void setFormat(format fmt);

      void setTime(const utils::Time time) { m_timestamp = time; }
      void setTime() { m_timestamp = utils::Time::now(); }



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


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


      icl64f getMin() const;

      icl64f getMax() const;


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


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




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



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


      void clear(int iChannel = -1, icl64f val=0, bool bROIOnly=true);


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


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



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


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


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



      void print(const std::string sTitle="image") const;

      bool validChannel(const int iChannel) const {
        return iChannel >= 0 && iChannel < getChannels();
      }


      bool isEqual(const utils::Size &s, int nChannels) const {
        FUNCTION_LOG("isEqual("<<s.width<<","<< s.height << ","<< nChannels << ")");
        return (getSize() == s) && (getChannels() == nChannels);
      }

      bool isEqual(const ImgParams &params){
        FUNCTION_LOG("");
        return m_oParams == params;
      }

      bool isEqual(const ImgParams &params, depth d){
        FUNCTION_LOG("");
        return m_oParams == params && getDepth() == d;
      }

      bool isEqual(const ImgBase *otherImage){
        FUNCTION_LOG("");
        ICLASSERT_RETURN_VAL(otherImage,false);
        return getParams() == otherImage->getParams() && getDepth() == otherImage->getDepth();
      }


      virtual bool isIndependent() const=0;

      inline bool hasMetaData() const { return m_metaData.length(); }

      inline void setMetaData(const std::string &data){
        m_metaData = data;
      }

      inline void clearMetaData(){
        setMetaData("");
      }

      inline const std::string &getMetaData() const {
        return m_metaData;
      }

      std::string &getMetaData() {
        return m_metaData;
      }


      protected:

      ImgBase(depth d, const ImgParams& params);


      ImgParams m_oParams;

      depth m_eDepth;

      utils::Time m_timestamp;

      std::string m_metaData;
    };

    ICLCore_API std::ostream &operator<<(std::ostream &s, const ImgBase &image);
  } // namespace core
}