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.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 <ICLUtils/StringUtils.h>
#include <ICLUtils/Exception.h>
#include <ICLCore/Img.h>

namespace icl{
  namespace utils{}
  namespace math{}
  namespace core{}
  namespace filter{}
  namespace io{}
  namespace qt{}
  namespace geom{}
  namespace cv{}
  namespace markers{}
  namespace physics{}
}

#ifndef ICL_NO_USING_NAMESPACES
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 icl::physics;
#endif

using namespace std;

namespace icl{
  namespace qt{

  #ifdef ICL_HAVE_QT

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


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


    std::string textInputDialog(const std::string &caption="text ...",
                                const std::string &message="please write your text here",
                                const std::string &initialText="",
                                void *parentWidget=0,
                                core::ImgBase *visImage=0,
                                std::vector<std::string> completionOptions=std::vector<std::string>()) ;



    ICLQt_API 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> ICLQt_API
    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> ICLQt_API
    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> ICLQt_API
    core::Img<T> load(const std::string &filename);

    inline ImgQ load(const std::string &filename) { return load<ICL_QUICK_TYPE>(filename); }

    template<class T> ICLQt_API
    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> ICLQt_API
    core::Img<T> create(const std::string &name, core::format fmt=icl::core::formatRGB);

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

    template<class T> ICLQt_API
    core::Img<T> grab(const std::string &dev, const std::string &devSpec,
                const utils::Size &size=utils::Size::null, core::format fmt=core::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=icl::core::formatRGB,
                     bool releaseGrabber=false){
      return grab<ICL_QUICK_TYPE>(dev,devSpec,size,fmt,releaseGrabber);
    }
    /* }}} */

    /* {{{ open */


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


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


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


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


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


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


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


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


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


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

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



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

    /* {{{ open */


    template<class T> ICLQt_API
    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> ICLQt_API
    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);
    }

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


    ICLQt_API ImgQ rgb(const ImgQ &image);


    ICLQt_API ImgQ hls(const ImgQ &image);


    ICLQt_API ImgQ lab(const ImgQ &image);


    ICLQt_API ImgQ gray(const ImgQ &image);


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


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


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


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


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


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


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


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


    ICLQt_API ImgQ flipx(const ImgQ& image);


    ICLQt_API ImgQ flipy(const ImgQ& image);

    /* }}} */

    /* {{{ open */


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


    ICLQt_API void show(const icl::core::ImgBase &image);


    ICLQt_API 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 */


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


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


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


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


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


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


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


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


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


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


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


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


    ICLQt_API ImgQ operator-(const ImgQ &image);

    /* }}} */

    /* {{{ open */


    ICLQt_API ImgQ exp(const ImgQ &image);


    ICLQt_API ImgQ ln(const ImgQ &image);


    ICLQt_API ImgQ sqr(const ImgQ &image);


    ICLQt_API ImgQ sqrt(const ImgQ &image);


    ICLQt_API ImgQ abs(const ImgQ &image);

    /* }}} */

    /* {{{ open */



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


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

    template<class T> ICLQt_API
    ImgQ binOR(const ImgQ &a, const ImgQ &b);

    template<class T> ICLQt_API
    ImgQ binXOR(const ImgQ &a, const ImgQ &b);

    template<class T> ICLQt_API
    ImgQ binAND(const ImgQ &a, const ImgQ &b);

    /* }}} */

    /* {{{ open */


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


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


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

    /* }}} */

    /* {{{ open */



    struct ICLQt_API ImgROI{
      ImgQ image;


      ImgROI &operator=(const ImgQ &i);


      ImgROI &operator=(float val);


      ImgROI &operator=(const ImgROI &r);

      operator ImgQ();
    };


    ICLQt_API ImgROI roi(ImgQ &r);


    ICLQt_API ImgROI data(ImgQ &r);

    /* }}} */

    /* {{{ open */


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


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


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


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


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


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


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


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


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

    ICLQt_API void polygon(ImgQ &image, const std::vector<utils::Point> &corners);


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


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


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


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


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


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


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


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


    ICLQt_API void fontsize(int size);
    /* }}} */

    /* {{{ open */

    ICLQt_API void tic(const std::string &label = "");

    ICLQt_API void toc();
    /* }}} */

  } // namespace qt
}