DrawWidget.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/DrawWidget.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 <ICLQt/Widget.h>
#include <QtCore/QMutex>
#include <ICLUtils/Point32f.h>
#include <ICLUtils/Rect32f.h>
#include <ICLMath/FixedMatrix.h>
#include <ICLUtils/VisualizationDescription.h>

namespace icl{
  namespace core{ class ImgBase; }
  namespace qt{
    class GLPaintEngine;


    class ICLDrawWidget : public ICLWidget {
      template<class T> 
      static inline void icl_given_type_has_no_int_index_operator(const T &t){
        t[0];
      }

      public:
      enum Sym {symRect,symCross,symPlus,symTriangle,symCircle};
    
      ICLDrawWidget(QWidget *parent=0);

      ~ICLDrawWidget();


      void setAutoResetQueue(bool on);
    

      void resetQueue();
    
#if 0


      ICL_DEPRECATED void lock(){}//m_oCommandMutex.lock();}

      ICL_DEPRECATED void unlock(){}//{m_oCommandMutex.unlock();}
#endif


      void abs();
    
      void rel();
    

      void image(core::ImgBase *image, float x, float y, float w, float h);
    
      inline void image(core::ImgBase *image, const utils::Rect &r){
        this->image(image,r.x,r.y,r.width,r.height);
      }
    

      void image(const core::ImgBase *image, const float a[2], const float b[2],
                 const float c[2], const float d[2]);
    

      void text(std::string text, float x, float y, float w, float h, float fontsize=10);

      /*    The given fontsize paramter defines the font-size in screen pixels.
          <b>Important: if the given fontsize is negative, its absolute value is used
          but the font size unit is image pixels instead of screen-pixels </b>
          */
      void text(const std::string &text, float x, float y, float fontsize=10){
        this->text(text,x,y,-1,-1,fontsize);
      }
    
      void text(const std::string &text, const utils::Point32f &p, float fontsize=10){
        this->text(text,p.x,p.y,-1,-1,fontsize);
      }

      void point(float x, float y); 

      void point(const utils::Point &p){
        this->point(p.x,p.y);
      }

      void point(const utils::Point32f &p){
        this->point(p.x,p.y);
      }

      template<class VectorType>
      void point(const VectorType &p){
        icl_given_type_has_no_int_index_operator(p);
        this->point(p[0],p[1]);
      }
    

      void points(const std::vector<utils::Point> &pts, int xfac=1, int yfac=1);

      void points(const std::vector<utils::Point32f> &pts);
    
      template<class VectorType>
      void point(const std::vector<VectorType> &points){
        icl_given_type_has_no_int_index_operator(points[0]);
        std::vector<utils::Point32f> tmp(points.size());
        for(unsigned int i=0;i<points.size();++i) tmp[i] = utils::Point32f(points[i][0],points[i][1]);
        this->points(tmp);
      }
    
    

      void linestrip(const std::vector<utils::Point> &pts, bool closeLoop=true, int xfac=1, int yfac=1);

      void linestrip(const std::vector<utils::Point32f> &pts, bool closeLoop=true);
    
    
      void line(float x1, float y1, float x2, float y2);
    
      void line(const utils::Point32f &a, const utils::Point32f &b);

      template<class VectorTypeA, class VectorTypeB>
      void line(const VectorTypeA &a, const VectorTypeB &b){
        icl_given_type_has_no_int_index_operator(a);
        icl_given_type_has_no_int_index_operator(b);
        this->line(a[0],a[1],b[0],b[1]);
      }

      void arrow(float ax, float ay, float bx, float by, float capsize=10);
    
      void arrow(const utils::Point32f &a, const utils::Point32f &b, float capsize=10);
    
      void rect(float x, float y, float w, float h);

      void rect(const utils::Rect32f &r);

      void rect(const utils::Rect &r);

      void triangle(float x1, float y1, float x2, float y2, float x3, float y3); 
    
      void triangle(const utils::Point32f &a, const utils::Point32f &b, const utils::Point32f &c);
    
      void quad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4); 

      void quad(const utils::Point32f &a, const utils::Point32f &b, const utils::Point32f &c, const utils::Point32f &d);

      void ellipse(float x, float y, float w, float h);
    
      void ellipse(const utils::Rect &r);
    
      void ellipse(const utils::Rect32f &r);
    
      void circle(float cx, float cy, float r);
    
      void circle(const utils::Point32f &center, float radius);
    
      void polygon(const std::vector<utils::Point32f> &ps);

      void polygon(const std::vector<utils::Point> &ps);

      void grid(const utils::Point32f *points, int nx, int ny, bool rowMajor=true);


      void sym(float x, float y, Sym s);

      void sym(const utils::Point32f &p, Sym s){
        sym(p.x,p.y,s);
      }
    

      void sym(float x, float y, char sym){
        if(sym == 'r') this->sym(x,y,symRect);
        else if(sym == '+') this->sym(x,y,symPlus);
        else if(sym == 't') this->sym(x,y,symTriangle);
        else if(sym == 'o') this->sym(x,y,symCircle);
        else this->sym(x,y,symCross);
      }

      void sym(const utils::Point32f &p, char sym){
        this->sym(p.x,p.y,sym);
      }
    
      void symsize(float w, float h=-1); // if h==-1, h = w;

      void linewidth(float w);

      void pointsize(float s);
    

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

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

      template<class T, unsigned int COLS>
      inline void color(const math::FixedMatrix<T,COLS,3/COLS> &v){
        color((float)v[0],(float)v[1],(float)v[2]);
      }

      template<class T, unsigned int COLS>
      inline void color(const math::FixedMatrix<T,COLS,4/COLS> &v){
        color((float)v[0],(float)v[1],(float)v[2],(float)v[3]);
      }

      template<class T, unsigned int COLS>
      inline void fill(const math::FixedMatrix<T,COLS,3/COLS> &v){
        fill((float)v[0],(float)v[1],(float)v[2]);
      }

      template<class T, unsigned int COLS>
      inline void fill(const math::FixedMatrix<T,COLS,4/COLS> &v){
        fill((float)v[0],(float)v[1],(float)v[2],(float)v[3]);
      }
    
      void nocolor();
    
      void nofill();


      void draw(const utils::VisualizationDescription &d);
      
      virtual void customPaintEvent(PaintEngine *e);

      virtual void initializeCustomPaintEvent(PaintEngine *e);

      virtual void finishCustomPaintEvent(PaintEngine *e);

    
      class State;

      class DrawCommand;

      protected:    

      virtual void swapQueues();


      std::vector<DrawCommand*> *m_queues[2];

      State *m_poState;

      QMutex m_oCommandMutex;
    
      bool m_autoResetQueue;
    };
  } // namespace qt
}