OpenCV.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/OpenCV.h                           **
** Module : ICLCore                                                **
** Authors: Christof Elbrechter, Christian Groszewski              **
**                                                                 **
**                                                                 **
** 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 <opencv/cxcore.h>

#include <ICLCore/CCFunctions.h>
#include <ICLCore/Img.h>
#include <ICLCore/ImgBase.h>

#include <ICLUtils/Uncopyable.h>

namespace icl{
  namespace core{
  
    enum DepthPreference{
      PREFERE_SRC_DEPTH, 
      PREFERE_DST_DEPTH  
    };
  

    ICLCore_API ImgBase *ipl_to_img(CvArr *src,ImgBase **dst=0,DepthPreference e=PREFERE_SRC_DEPTH) throw (utils::ICLException);
  

    ICLCore_API IplImage *img_to_ipl(const ImgBase *src, IplImage **dst = 0, DepthPreference e = PREFERE_SRC_DEPTH)throw (utils::ICLException);
  

    ICLCore_API CvMat* img_to_cvmat(const ImgBase *src, CvMat *dst = 0, int channel = 0) throw (utils::ICLException);
  

    ICLCore_API IplImage *img_to_ipl_shallow(ImgBase *src, IplImage *dst = 0)throw (utils::ICLException);
  

    ICLCore_API CvMat *img_to_cvmat_shallow(const ImgBase *src, CvMat *dst = 0) throw (utils::ICLException);


    

    template<class T>
    inline int icl_get_cv_mat_type() { 
      throw utils::ICLException("icl_get_cv_mat_type: invalid type");
      return 0; 
    }
   
    template<> inline int icl_get_cv_mat_type<int>() { return CV_32SC1; }

    template<> inline int icl_get_cv_mat_type<float>() { return CV_32FC1; }

    struct CvMatDelOp : public utils::DelOpBase{ 
      static void delete_func(CvMat *m){ 
        if(m) cvReleaseMat(&m);
      } 
    };


    template<class T>
    class CvMatWrapper : public utils::Uncopyable{
      utils::Size size; 
      utils::SmartPtrBase<CvMat,CvMatDelOp> m;

      public:
      CvMatWrapper(int nrows=0, int ncols=0):
        size(ncols, nrows),
        m( nrows * ncols > 0 ? cvCreateMat(nrows, ncols, icl_get_cv_mat_type<T>()) : 0, true){}

      CvMatWrapper(const utils::Size &size):
        size(size),
        m( size.getDim() > 0 ? cvCreateMat(size.height, size.width, icl_get_cv_mat_type<T>()) : 0, true){}
      

      CvMatWrapper(CvMat *other, bool takeOwnerShip=false):
        size(0,0), m(other, takeOwnerShip){

        if(other){
          CvSize size = cvGetSize(other);
          this->size = utils::Size(size.width,size.height);
        }
      }
        
      CvMat *get() { return m.get(); }

      const CvMat *get() const { return m.get(); }
      


      inline void setSize(const utils::Size &size){
        if(size == this->size) return;
        this->size = size;
        if(size.getDim() > 0){
          CvMat *m = cvCreateMat(size.height, size.width, icl_get_cv_mat_type<T>());
          this->m = utils::SmartPtrBase<CvMat,CvMatDelOp>(m,true);
        }else{
          this->m = utils::SmartPtrBase<CvMat,CvMatDelOp>();
        }
      }
      
      inline bool isNull() const { return m.get() == 0; }

      inline const utils::Size &getSize() const {
        return size;
      }
      
      T &operator()(int y, int x) {
        return CV_MAT_ELEM(*m,T,y,x);
      }

      const T &operator()(int y, int x) const{
        return CV_MAT_ELEM((const_cast<CvMat&>(*m)),T,y,x);
      }

    };
      
    template<class T>
    inline std::ostream &operator<<(std::ostream &str, const CvMatWrapper<T> &m){
      utils::Size s = m.getSize();
      std::cout << "CvMatWrapper of a " <<  s.height << " x " << s.width << " matrix:" << "\n";

      for(int y=0;y<s.height;++y){
        for(int x=0;x<s.width;++x){
          str << m(y,x) << ((x == s.width-1) ? "\n" : "  ");
        }
      }
      return str;
    }

  } // namespace core
}