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
}