Quick.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   : ICLQt/src/ICLQt/Quick.h                                **
** Module : ICLQt                                                  **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** 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 <ICLCore/Img.h>
#include <ICLUtils/StringUtils.h>
#include <ICLUtils/Exception.h>

namespace icl{
  namespace utils{}
  namespace math{}
  namespace core{}
  namespace filter{}
  namespace io{}
  namespace qt{}
  namespace geom{}
  namespace cv{}
  namespace markers{}
}
using namespace icl;
using namespace icl::utils;
using namespace icl::math;
using namespace icl::core;
using namespace icl::filter;
using namespace icl::io;
using namespace icl::qt;
using namespace icl::geom;
using namespace icl::cv;
using namespace icl::markers;

using namespace std;

namespace icl{
  namespace qt{
  
  #ifdef HAVE_QT


    std::string openFileDialog(const std::string &filter="", 
                               const std::string &caption="open file",
                               const std::string &initialDirectory="", 
                               void *parentWidget=0) throw (utils::ICLException);
  

    std::string saveFileDialog(const std::string &filter="", 
                               const std::string &caption="save file",
                               const std::string &initialDirectory="", 
                               void *parentWidget=0) throw (utils::ICLException);
  

    std::string execute_process(const std::string &command);
  #endif
  
  #define ICL_QUICK_DEPTH depth32f
  #define ICL_QUICK_TYPE icl32f
    
      
    typedef core::Img<ICL_QUICK_TYPE> ImgQ;
  
    /* {{{ open */

    template<class T>
    core::Img<T> zeros(int width, int height, int channels=1);
    
    /***/
    inline ImgQ zeros(int width, int height, int channels=1){ 
      return zeros<ICL_QUICK_TYPE>(width,height,channels); 
    }
    
    

    template<class T>
    core::Img<T> ones(int width, int height, int channels=1);
  
    inline ImgQ ones(int width, int height, int channels=1){ return ones<ICL_QUICK_TYPE>(width,height,channels);  }


    template<class T>
    core::Img<T> load(const std::string &filename);
  
    inline ImgQ load(const std::string &filename) { return load<ICL_QUICK_TYPE>(filename); }


    template<class T>
    core::Img<T> load(const std::string &filename, core::format fmt);
  
    inline ImgQ load(const std::string &filename, core::format fmt) { return load<ICL_QUICK_TYPE>(filename,fmt); }


    template<class T>
    core::Img<T> create(const std::string &name, core::format fmt=formatRGB);
  
    inline ImgQ create(const std::string &name, core::format fmt=formatRGB) { return create<ICL_QUICK_TYPE>(name,fmt); }


    template<class T>
    core::Img<T> grab(const std::string &dev, const std::string &devSpec, 
                const utils::Size &size=utils::Size::null, core::format fmt=formatRGB,
                bool releaseGrabber=false);
  
    inline ImgQ grab(const std::string &dev, const std::string &devSpec, 
                     const utils::Size &size=utils::Size::null, core::format fmt=formatRGB,
                     bool releaseGrabber=false){
      return grab<ICL_QUICK_TYPE>(dev,devSpec,size,fmt,releaseGrabber);
    }
    /* }}} */
  
    /* {{{ open */
  

    core::Img8u cvt8u(const ImgQ &image);
  

    core::Img16s cvt16s(const ImgQ &image);
  

    core::Img32s cvt32s(const ImgQ &image);
  

    core::Img32f cvt32f(const ImgQ &image);
  

    core::Img64f cvt64f(const ImgQ &image);
  

    ImgQ cvt(const core::Img8u &image);
  


    ImgQ cvt(const core::Img16s &image);
  

    ImgQ cvt(const core::Img32s &image);
  

    ImgQ cvt(const core::Img32f &image);


    ImgQ cvt(const core::Img64f &image);


    ImgQ cvt(const core::ImgBase *image);
  
  

    ImgQ cvt(const core::ImgBase &image);
    /* }}} */
  
    /* {{{ open */
  

    template<class T>
    core::Img<T> filter(const core::Img<T> &image, const std::string &filter);
    
    inline ImgQ filter(const ImgQ &image, const std::string &filter){
      return icl::qt::filter<float>(image,filter);
    }


    template<class T>
    core::Img<T> blur(const core::Img<T> &image, int maskRadius=1);
    
    inline ImgQ blur(const ImgQ &image, int maskRadius=1){
      return icl::qt::blur<float>(image,maskRadius);
    }


    ImgQ cc(const ImgQ& image, core::format fmt);
    

    ImgQ rgb(const ImgQ &image);
    

    ImgQ hls(const ImgQ &image);
  

    ImgQ lab(const ImgQ &image);
  

    ImgQ gray(const ImgQ &image);
    

    ImgQ scale(const ImgQ& image, float factor);
  

    ImgQ scale(const ImgQ& image, int width, int height);
    

    ImgQ channel(const ImgQ &image,int channel);
  

    ImgQ levels(const ImgQ &image, icl8u levels);
    

    ImgQ thresh(const ImgQ &image, float threshold);
   

    template<class T>
    core::Img<T> copy(const core::Img<T> &image);
    

    template <class T>
    core::Img<T> copyroi(const core::Img<T> &image);
    

    template<class T>
    core::Img<T> norm(const core::Img<T> &image);
    

    ImgQ flipx(const ImgQ& image);
  

    ImgQ flipy(const ImgQ& image);
  
    /* }}} */
    
    /* {{{ open */
    

    void save(const core::ImgBase &image, const std::string &filename);
    

    void show(const ImgBase &image);
    

    void showSetup(const string &showCommand="xv %s", const string &rmCommand="rm -rf %s", int msecBeforeDelete=500);
    

    template<class T>
    void print(const core::Img<T> &image);
  
    /* }}} */
    
    /* {{{ open */
  

    ImgQ operator+(const ImgQ &a, const ImgQ &b);
    

    ImgQ operator-(const ImgQ &a, const ImgQ &b);
    

    ImgQ operator*(const ImgQ &a, const ImgQ &b);
  

    ImgQ operator/(const ImgQ &a, const ImgQ &b);
  

    ImgQ operator+(const ImgQ &image, float val);
  

    ImgQ operator-(const ImgQ &image, float val);
  

    ImgQ operator*(const ImgQ &image, float val);
  

    ImgQ operator/(const ImgQ &image, float val);
  

    ImgQ operator+(float val, const ImgQ &image);
  

    ImgQ operator-(float val, const ImgQ &image);
    

    ImgQ operator*(float val, const ImgQ &image);
    

    ImgQ operator/(float val, const ImgQ &image);
  

    ImgQ operator-(const ImgQ &image);
  
    /* }}} */
    
    /* {{{ open */
  

    ImgQ exp(const ImgQ &image);
  

    ImgQ ln(const ImgQ &image);
  

    ImgQ sqr(const ImgQ &image);
    

    ImgQ sqrt(const ImgQ &image);
    

    ImgQ abs(const ImgQ &image);
    
    /* }}} */
    
    /* {{{ open */
  
    

    ImgQ operator||(const ImgQ &a, const ImgQ &b);
  

    ImgQ operator&&(const ImgQ &a, const ImgQ &b);
  
    template<class T>
    ImgQ binOR(const ImgQ &a, const ImgQ &b);
    
    template<class T>
    ImgQ binXOR(const ImgQ &a, const ImgQ &b);
  
    template<class T>
    ImgQ binAND(const ImgQ &a, const ImgQ &b);
    
    /* }}} */
    
    /* {{{ open */
  

    ImgQ operator,(const ImgQ &a, const ImgQ &b);
    

    ImgQ operator%(const ImgQ &a, const ImgQ &b);
  

    ImgQ operator|(const ImgQ &a, const ImgQ &b);
  
    /* }}} */
    
    /* {{{ open */
  
  

    struct ImgROI{
      ImgQ image;
      

      ImgROI &operator=(const ImgQ &i);
      

      ImgROI &operator=(float val);
      

      ImgROI &operator=(const ImgROI &r);
      
      operator ImgQ();
    };
    

    ImgROI roi(ImgQ &r);
    

    ImgROI data(ImgQ &r);
  
    /* }}} */
    
    /* {{{ open */
  

    void color(float r, float g=-1, float b=-1, float alpha=255);
  

    void fill(float r, float g=-1, float b=-1, float alpha=255);
  

    void colorinfo(float color[4], float fill[4]);
    

    void cross(ImgQ &image, int x, int y);
  

    inline void cross(ImgQ &image, const utils::Point &p) { cross(image,p.x,p.y); }
  

    void rect(ImgQ &image, int x, int y, int w, int h, int rounding=0);
  

    inline void rect(ImgQ &image, const utils::Rect &r, int rounding=0){ rect(image,r.x,r.y,r.width,r.height,rounding); }
    

    void triangle(ImgQ &image, int x1,int y1, int x2, int y2, int x3, int y3);
  
    inline void triangle(ImgQ &image, const utils::Point &a, const utils::Point &b, const utils::Point &c){
      triangle(image,a.x,a.y,b.x,b.y,c.x,c.y);
    }
    

    void line(ImgQ &image, int x1, int y1, int x2, int y2); 
  

    inline void line(ImgQ &image, const utils::Point &p1, const utils::Point &p2){ line(image,p1.x,p1.y, p2.x,p2.y); }
  

    void linestrip(ImgQ &image, const std::vector<utils::Point> &pts, bool closeLoop=true);
    
    void polygon(ImgQ &image, const std::vector<utils::Point> &corners);
    

    void pix(ImgQ &image, int x, int y);
  

    inline void pix(ImgQ &image, const utils::Point &p){ pix(image,p.x,p.y); }
    

    void pix(ImgQ &image, const vector<utils::Point> &pts);
  

    void pix(ImgQ &image, const vector<vector<utils::Point> > &pts);
    

    void circle(ImgQ &image, int x, int y, int r);
    

    void text(ImgQ &image, int x, int y,const string &text);
  

    inline void text(ImgQ &image, const utils::Point &p,const string &sText){ text(image,p.x,p.y,sText); }
  

    ImgQ label(const ImgQ &image, const string &text);
  

    void font(int size, const string &family="Arial");
    

    void fontsize(int size);
    /* }}} */
  
    /* {{{ open */
  
    void tic(const std::string &label="");
    
    void toc();
    /* }}} */
                  
  } // namespace qt
}