CoreFunctions.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/CoreFunctions.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.GPL  **
** 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 <string>
#include <cstring>
#include <iostream>
#include <vector>

#include <ICLUtils/Macros.h>
#include <ICLUtils/Point32f.h>
#include <ICLUtils/ClippedCast.h>
#include <ICLUtils/PThreadFix.h>

#include <ICLCore/Types.h>
#include <ICLCore/ImgParams.h>


namespace icl {
  namespace core{
   
  /* {{{ Global functions */
  

    ImgBase *imgNew(depth d=depth8u, const ImgParams &params = ImgParams::null);
    
    inline ImgBase *imgNew(depth d, const utils::Size& size, format fmt, 
                           const utils::Rect &roi=utils::Rect::null){
      return imgNew(d,ImgParams(size,fmt,roi));
    }
  
    inline ImgBase *imgNew(depth d, const utils::Size& size, int channels=1, 
                           const utils::Rect &roi=utils::Rect::null){
      return imgNew(d,ImgParams(size,channels,roi));
    }
   
    inline ImgBase *imgNew(depth d, const utils::Size& size, int channels, format fmt, 
                           const utils::Rect &roi=utils::Rect::null){
      return imgNew(d,ImgParams(size,channels,fmt,roi));
    }
  
    

    ImgBase *ensureDepth(ImgBase **ppoImage, depth eDepth);
  
    ImgBase *ensureCompatible(ImgBase **dst, depth d,const ImgParams &params);
  

    inline ImgBase *ensureCompatible(ImgBase **dst, depth d,const utils::Size& size,int channels, const utils::Rect &roi=utils::Rect::null)
       { return ensureCompatible(dst,d,ImgParams(size,channels,roi)); }
  
    inline ImgBase *ensureCompatible(ImgBase **dst, depth d,const utils::Size& size, format fmt, const utils::Rect &roi=utils::Rect::null)
       { return ensureCompatible(dst,d,ImgParams(size,fmt,roi)); }
    

    ImgBase *ensureCompatible(ImgBase **dst, depth d, const utils::Size &size, int channels, format fmt, const utils::Rect &roi=utils::Rect::null);
    

    ImgBase *ensureCompatible(ImgBase **dst, const ImgBase *src);
  

    int getChannelsOfFormat(format fmt);
  
    template<class T> inline depth getDepth();
  
  
    std::ostream &operator<<(std::ostream &s,const format &f);
    
    std::ostream &operator<<(std::ostream &s,const depth &d);
  
    std::istream &operator>>(std::istream &s, format &f);
    
    std::istream &operator>>(std::istream &s, depth &d);
  
    
  #define ICL_INSTANTIATE_DEPTH(T)                                        \
    template<> inline depth getDepth<icl ## T>() { return depth ## T; }
  ICL_INSTANTIATE_ALL_DEPTHS  
  #undef ICL_INSTANTIATE_DEPTH


    unsigned int getSizeOf(depth eDepth);
  
    template <class T>
    inline void copy(const T *src, const T *srcEnd, T *dst){
      //std::copy<T>(src,srcEnd,dst);
      memcpy(dst,src,(srcEnd-src)*sizeof(T));
    } 
  
  
  #ifdef HAVE_IPP

    template <>
    inline void copy<icl8u>(const icl8u *poSrcStart, const icl8u *poSrcEnd, icl8u *poDst){
      ippsCopy_8u(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template <>
    inline void copy<icl16s>(const icl16s *poSrcStart, const icl16s *poSrcEnd, icl16s *poDst){
      ippsCopy_16s(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template <>
    inline void copy<icl32s>(const icl32s *poSrcStart, const icl32s *poSrcEnd, icl32s *poDst){
      ippsCopy_32s(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template <>
    inline void copy<icl32f>(const icl32f *poSrcStart, const icl32f *poSrcEnd, icl32f *poDst){
      ippsCopy_32f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template <>
    inline void copy<icl64f>(const icl64f *poSrcStart, const icl64f *poSrcEnd, icl64f *poDst){
      ippsCopy_64f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
  #endif
  
  
  
  
    template <class srcT,class dstT>
    inline void convert(const srcT *poSrcStart,const srcT *poSrcEnd, dstT *poDst){
      std::transform(poSrcStart,poSrcEnd,poDst,utils::clipped_cast<srcT,dstT>);
    }
    
  #ifdef HAVE_IPP 


    template<> inline void convert<icl8u,icl32f>(const icl8u *poSrcStart,const icl8u *poSrcEnd, icl32f *poDst){
      ippsConvert_8u32f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template<> inline void convert<icl16s,icl32s>(const icl16s *poSrcStart,const icl16s *poSrcEnd, icl32s *poDst){
      ippsConvert_16s32s(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template<> inline void convert<icl16s,icl32f>(const icl16s *poSrcStart,const icl16s *poSrcEnd, icl32f *poDst){
      ippsConvert_16s32f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template<> inline void convert<icl16s,icl64f>(const icl16s *poSrcStart,const icl16s *poSrcEnd, icl64f *poDst){
      ippsConvert_16s64f_Sfs(poSrcStart,poDst,(poSrcEnd-poSrcStart),0);
    }
    
    // from icl32s functions
    template<> inline void convert<icl32s,icl16s>(const icl32s *poSrcStart,const icl32s *poSrcEnd, icl16s *poDst){
      ippsConvert_32s16s(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template<> inline void convert<icl32s,icl32f>(const icl32s *poSrcStart,const icl32s *poSrcEnd, icl32f *poDst){
      ippsConvert_32s32f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template<> inline void convert<icl32s,icl64f>(const icl32s *poSrcStart,const icl32s *poSrcEnd, icl64f *poDst){
      ippsConvert_32s64f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
  
    // from icl32f functions
    template <> inline void convert<icl32f,icl8u>(const icl32f *poSrcStart, const icl32f *poSrcEnd, icl8u *poDst){
      ippsConvert_32f8u_Sfs(poSrcStart,poDst,(poSrcEnd-poSrcStart),ippRndNear,0);
    } 
    template <> inline void convert<icl32f,icl16s>(const icl32f *poSrcStart, const icl32f *poSrcEnd, icl16s *poDst){
      ippsConvert_32f16s_Sfs(poSrcStart,poDst,(poSrcEnd-poSrcStart),ippRndNear,0);
    } 
    template <> inline void convert<icl32f,icl32s>(const icl32f *poSrcStart, const icl32f *poSrcEnd, icl32s *poDst){
      ippsConvert_32f32s_Sfs(poSrcStart,poDst,(poSrcEnd-poSrcStart),ippRndNear,0);
    } 
    template <> inline void convert<icl32f,icl64f>(const icl32f *poSrcStart, const icl32f *poSrcEnd, icl64f *poDst){
      ippsConvert_32f64f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    } 
  
    // from icl64f functions 
    template<> inline void convert<icl64f,icl32f>(const icl64f *poSrcStart,const icl64f *poSrcEnd, icl32f *poDst){
      ippsConvert_64f32f(poSrcStart,poDst,(poSrcEnd-poSrcStart));
    }
    template <> inline void convert<icl64f,icl32s>(const icl64f *poSrcStart,const icl64f *poSrcEnd, icl32s *poDst){
      ippsConvert_64f32s_Sfs(poSrcStart,poDst,(poSrcEnd-poSrcStart),ippRndNear,0);
    }
  #endif 
  
  
   

    template<class T>
    inline void getMinAndMax(T a, T b, T c, T &minVal, T &maxVal){
      if(a<b) {
        minVal=a;
        maxVal=b;
      }
      else {
        minVal=b;
        maxVal=a;       
      }
      if(c<minVal)
        minVal=c;
      else {
        maxVal = c>maxVal ? c : maxVal;
      }
    }  
  
    /* }}} */


    std::vector<double> mean(const ImgBase *poImg, int iChannel=-1, bool roiOnly=false);


    std::vector<double> variance(const ImgBase *poImg, const std::vector<double> &mean, bool empiricMean=true,  int iChannel=-1, bool roiOnly=false);
    

    std::vector<double> variance(const ImgBase *poImg, int iChannel=-1, bool roiOnly=false); 


    std::vector<double> stdDeviation(const ImgBase *poImage, int iChannel=-1, bool roiOnly = false);
    

    std::vector<double> stdDeviation(const ImgBase *poImage, const std::vector<double> mean, bool empiricMean=true, int iChannel=-1, bool roiOnly = false);
  

    std::vector< std::pair<double,double> > meanAndStdDev(const ImgBase *image, int iChannel=-1, bool roiOnly = false);
    
    
    std::vector<int> channelHisto(const ImgBase *image,int channel, int levels=256, bool roiOnly=false);
    
    std::vector<std::vector<int> > hist(const ImgBase *image, int levels=256, bool roiOnly=false);
  
  } // namespace core
} // namespace icl