PlotWidget.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/PlotWidget.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/Array2D.h>
#include <ICLUtils/VisualizationDescription.h>
#include <ICLMath/FixedVector.h>
#include <ICLQt/LowLevelPlotWidget.h>

namespace icl{
  namespace qt{


    class ICLQt_API PlotWidget : public LowLevelPlotWidget{
      struct Data;  
      Data *m_data; 

      public:


      PlotWidget(QWidget *parent=0);

      ~PlotWidget();

      inline void lock() { LowLevelPlotWidget::lock(); }

      inline void unlock() { LowLevelPlotWidget::unlock(); }

      virtual void clear();

      inline void reset() { clear(); }

      void label(const std::string &primitiveLabel);

      inline void nolabel() { label(""); }

      void color(int r, int g, int b, int a=255);


      template<class VectorType>
      inline void color(const VectorType &c){
        color(c[0],c[1],c[2],c[3]);
      }

      inline void nocolor(){ color(0,0,0,0); }


      void pen(const QPen &pen);


      void fill(int r, int g, int b, int a=255);



      template<class VectorType>
      inline void fill(const VectorType &c){
        fill(c[0],c[1],c[2],c[3]);
      }
      inline void nofill() { fill(0,0,0,0); }


      void brush(const QBrush &brush);


      void sym(char s);


      inline void sym(char s, int symsize){
        sym(s);
        this->symsize(symsize);
      }

      inline void nosym() { sym(' '); }

      void linewidth(float width);

      void symsize(float size);



      template<class T> ICLQt_API
      void scatter(const T *xs, const T *ys, int num, int xStride = 1, int yStride=1, bool connect=false);

      inline void scatter(const std::vector<utils::Point32f> &ps, bool connect=false){
        scatter(&ps[0].x, &ps[0].y, ps.size(), 2, 2, connect);
      }

      inline void scatter(const std::vector<utils::Point> &ps, bool connect=false){
        scatter(&ps[0].x, &ps[0].y, ps.size(), 2, 2, connect);
      }

      template<class T>
      inline void scatter(const math::FixedMatrix<T,1,2> *ps, int num, bool connect=false){
        scatter(&ps[0][0],&ps[0][1], num, 2, 2, connect);
      }

      template<class T>
      inline void scatter(const math::FixedMatrix<T,2,1> *ps, int num, bool connect=false){
        scatter(&ps[0][0],&ps[0][1], num, 2, 2, connect);
      }

      inline void scatter(const std::vector<math::FixedColVector<float,2> >&ps, bool connect=false){
        scatter((const math::FixedMatrix<float,2,1>*)ps.data(),ps.size(),connect);
      }


      template<class T> ICLQt_API
      void series(const T *data, int num, int stride=1);

      template<class T>
      inline void series(const std::vector<T> &data){
        series(data.data(), data.size(), 1);
      }


      struct SeriesBuffer : public std::vector<float>{
        explicit SeriesBuffer(int size=0):std::vector<float>(size){}
        inline void push(float f){
          for(size_t i=1; i< size();++i){
            this->operator[](i-1) = this->operator[](i);
          }
          this->back() = f;
        }
        inline SeriesBuffer &operator<<(float f){
          push(f);
          return *this;
        }

      };


      template<class T> ICLQt_API
      void bars(const T *data, int num, int stride=1);

      template<class T>
      inline void bars(const std::vector<T> &data){
        bars(data.data(), data.size(), 1);
      }

      void line(const utils::Point32f &a, const utils::Point32f &b);

      inline void line(float x1, float y1, float x2, float y2){
        line(utils::Point32f(x1,y1),utils::Point32f(x2,y2));
      }

      void linestrip(const std::vector<utils::Point32f> &ps, bool closedLoop=true);

      void linestrip(const std::vector<utils::Point> &ps, bool closedLoop=true);

      void linestrip(const utils::Point32f *ps, int num, bool closedLoop=true);

      void linestrip(const utils::Point *ps, int num, bool closedLoop=true);

      void linestrip(const float *xs, const float *ys, int num, bool closedLoop=true, int stride = 1);

      void rect(const utils::Point32f &ul, const utils::Point32f &lr);

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

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

      void rect(float x, float y, float w, float h);

      void circle(const utils::Point32f &c, float r);

      void circle(float cx, float cy, float r);


      void text(float x, float y, const std::string &text);


      void text(const utils::Point32f &p, const std::string &text);

      void grid(int nX, int nY, const float *xs, const float *ys, int stride=1);

      void grid(const utils::Array2D<utils::Point> &data);

      inline void grid(const utils::Array2D<utils::Point32f> &data){
        grid(data.getWidth(), data.getHeight(), &data(0,0).x, &data(0,0).y, 2);
      }

      inline void grid(int nX, int nY, const float *xys){
        grid(nX,nY,xys, xys+1,2);
      }

      inline void grid(int nX, int nY, const utils::Point *ps){
        grid(utils::Array2D<utils::Point>(nX,nY,const_cast<utils::Point*>(ps),false));
      }

      inline void grid(int nX, int nY, const utils::Point32f *ps){
        grid(nX, nY, &ps[0].x, &ps[0].y, 2);
      }

      inline void grid(int nX, int nY, const std::vector<utils::Point32f> &ps){
        grid(nX, nY, &ps[0].x, &ps[0].y, 2);
      }

      inline void grid(int nX, int nY, const std::vector<utils::Point> &ps){
        grid(utils::Array2D<utils::Point>(nX,nY, const_cast<utils::Point*>(ps.data()), false));
      }

      inline void grid(int nX, int nY, const std::vector<float> &xys){
        grid(nX, nY, xys.data(), xys.data()+1,2);
      }

      inline void grid(int nX, int nY, const std::vector<float> &xs, const std::vector<float> &ys){
        grid(nX, nY, xs.data(), ys.data());
      }


      void draw(const utils::VisualizationDescription &d);


      void title(const std::string &title){
        setPropertyValue("labels.diagramm",title);
      }

      void xlabel(const std::string &xlabel){
        setPropertyValue("labels.x-axis",xlabel);
      }

      void ylabel(const std::string &ylabel){
        setPropertyValue("labels.y-axis",ylabel);
      }

    };
  } // namespace qt
}