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

namespace icl{
  namespace qt{
    

    class 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>
      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>
      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>
      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
}