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>

#ifndef ICL_HAVE_OPENCV_OLD_STYLE

#include <opencv2/core/core.hpp>
#include <opencv2/core/version.hpp>

#if defined(CV_VERSION_EPOCH) && (CV_VERSION_EPOCH > 2)
#define ICL_HAVE_OPENCV_3
#elif !defined(CV_VERSION_EPOCH) && (CV_VERSION_MAJOR > 2)
#define ICL_HAVE_OPENCV_3
#endif

#endif

// crazy stuff !!
#ifdef ICL_HAVE_OPENCV_3
#define ICL_OPENCV_VERSION_MAJOR CV_VERSION_MAJOR
#define ICL_OPENCV_VERSION_MINOR CV_VERSION_MINOR
#else
#define ICL_OPENCV_VERSION_MAJOR CV_VERSION_EPOCH
#define ICL_OPENCV_VERSION_MINOR CV_VERSION_MAJOR
#endif


#if defined(ICL_HAVE_OPENCV_3)
  #include "opencv2/calib3d/calib3d_c.h"
// This will be inlcuded when at least OpenCV 2.4 is detected
#elif ICL_OPENCV_VERSION_MINOR > 3
  #include "opencv2/imgproc/types_c.h"
  #include "opencv2/imgproc/imgproc_c.h"
  #include "opencv2/calib3d/calib3d.hpp"
#else
  #error ICL requires at least OpenCV 2.4
#endif

#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) ;


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


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


    ICLCore_API IplImage *img_to_ipl_shallow(ImgBase *src, IplImage *dst = 0);


    ICLCore_API CvMat *img_to_cvmat_shallow(const ImgBase *src, CvMat *dst = 0) ;


    ICLCore_API ::cv::Mat *img_to_mat(const ImgBase *src, ::cv::Mat *dst=0) ;

    ICLCore_API ImgBase *mat_to_img(const ::cv::Mat *src, ImgBase *dstIn=0) ;

    ICLCore_API void mat_to_img(const ::cv::Mat *src, ImgBase **dstIn) ;


    struct ICLCore_API MatWrapper{
      ::cv::Mat mat;
      MatWrapper();
      MatWrapper(depth d, const utils::Size &size, int channels);
      MatWrapper(const MatWrapper &other);
      explicit MatWrapper(const ::cv::Mat &other);

      void adapt(depth d, const utils::Size &size, int channels);

      MatWrapper &operator=(const ::cv::Mat &other);
      MatWrapper &operator=(const MatWrapper &other);
      MatWrapper &operator=(const ImgBase &image);
      void copyTo(ImgBase **dst);
      void convertTo(ImgBase &dst);

      utils::Size getSize() const;
      int getChannels() const;
      depth getDepth() const;

      template<class T> ICLCore_API
      T* getInterleavedData();

      template<class T> ICLCore_API
      const T* getInterleavedData() const;
    };

    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(); }

      void operator=(const Img<T> &image){
        img_to_cvmat(&image, get(), 0);
      }


      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
}