VisualizationDescription.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   : ICLUtils/src/ICLUtils/VisualizationDescription.h       **
** Module : ICLUtils                                               **
** 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/Any.h>
#include <ICLUtils/Point32f.h>
#include <ICLUtils/Rect32f.h>

namespace icl{
  namespace utils{
    


    class VisualizationDescription{
      public:
      
      struct Part{
        inline Part(){}
        
        Part(char type, const Any &content):type(type),content(content){}

        char type;
        
        Any content;
      };

      struct Text{
        Point32f pos; 
        std::string text; 

        Text(){}
        
        Text(const Point32f &pos, const std::string &text):pos(pos),text(text){}
      };
      
      struct Color{
        union{
          icl8u comp[4];
          icl32s rgba; 
        };
        Color(){}
        
        Color(icl8u r, icl8u g, icl8u b, icl8u a=255){
          this->r() = r;
          this->g() = g;
          this->b() = b;
          this->a() = a;
        }
        inline icl8u &r() { return comp[0]; }

        inline icl8u &g() { return comp[1]; }

        inline icl8u &b() { return comp[2]; }

        inline icl8u &a() { return comp[3]; }

        inline const icl8u &r() const { return comp[0]; }

        inline const icl8u &g() const { return comp[1]; }

        inline const icl8u &b() const { return comp[2]; }

        inline const icl8u &a() const { return comp[3]; }

      };
      
      protected:

      std::vector<Part> parts;
      public:
      
      inline const std::vector<Part> &getParts() const { 
        return parts; 
      }
      
      inline void clear() { 
        parts.clear(); 
      }
      
      inline void addPart(const Part &part){
        parts.push_back(part);
      }
      inline void addPart(char c, const Any &content){
        addPart(Part(c,content));
      }
      

      VisualizationDescription &operator+=(const VisualizationDescription &other){
        size_t oldSize = parts.size();
        parts.resize(oldSize + other.parts.size());
        std::copy(other.parts.begin(),other.parts.end(),parts.begin()+oldSize);
        return *this;
      }
      

      VisualizationDescription operator+(const VisualizationDescription &other){
        VisualizationDescription sum;
        sum.parts.resize(parts.size()+other.parts.size());
        std::copy(parts.begin(),parts.end(),sum.parts.begin());
        std::copy(other.parts.begin(),other.parts.end(),sum.parts.begin()+parts.size());
        return sum;
      }
      
      void color(icl8u r, icl8u g, icl8u b);

      void color(icl8u r, icl8u g, icl8u b, icl8u a);

      void fill(icl8u r, icl8u g, icl8u b);

      void fill(icl8u r, icl8u g, icl8u b, icl8u a);

      inline void rect(icl32f x, icl32f y, icl32f width, icl32f height){
        addPart('r',Rect32f(x,y,width,height));
      }

      inline void rect(const Rect32f &r){
        addPart('r',r);
      }

      inline void ellipse(icl32f x, icl32f y, icl32f width, icl32f height){
        addPart('e',Rect32f(x,y,width,height));
      }

      inline void ellipse(const Rect32f &r){
        addPart('e',r);
      }

      inline void circle(icl32f cx, icl32f cy, icl32f radius){
        addPart('e',Rect32f(cx-radius,cy-radius,2*radius,2*radius));
      }

      inline void line(icl32f x1, icl32f y1, icl32f x2, icl32f y2){
        addPart('l',Rect32f(x1,y1,x2-x1,y2-y1));
      }

      inline void line(const Point32f &a, const Point32f &b){
        addPart('l',Rect32f(a.x,a.y,b.x-a.x,b.y-a.y));
      }

      inline void sym(char type, icl32f x, icl32f y){
        addPart(type,Point32f(x,y));
      }
      
      inline void sym(char type, const Point32f &p){
        addPart(type,p);
      }

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

      void text(const Point32f &pos, const std::string &text);
      
      void point(const Point32f &p){
        sym('.',p);
      }
      
      template<class Iterator>
      void points(Iterator begin, Iterator end){
        addPart('p',std::vector<float>(begin,end));
      }
      
      void points(const std::vector<Point32f> &ps){
        points(&ps[0].x,&ps[0].x + ps.size() * 2);
      }

      void points(const std::vector<Point> &ps){
        points(&ps[0].x,&ps[0].x + ps.size() * 2);
      }

      template<class Iterator>
      void polygon(Iterator begin, Iterator end){
        addPart('y',std::vector<float>(begin,end));
      }
      
      void polygon(const std::vector<Point32f> &ps){
        polygon(&ps[0].x,&ps[0].x + ps.size() * 2);
      }

      void polygon(const std::vector<Point> &ps){
        polygon(&ps[0].x,&ps[0].x + ps.size() * 2);
      }
      
      void linewidth(float w){
        addPart('L',w);
      }
      
      void pointsize(float s){
        addPart('P',s);
      }

    };
    
    inline std::ostream &operator<<(std::ostream &stream, const VisualizationDescription::Text &t){
      return (stream << t.pos << t.text);
    }

    inline std::istream &operator>>(std::istream &stream, VisualizationDescription::Text &t){
      stream >> t.pos;
      std::getline(stream,t.text);
      return stream;
    }

    inline std::ostream &operator<<(std::ostream &stream, const VisualizationDescription::Color &c){
      return (stream << c.rgba);
    }

    inline std::istream &operator>>(std::istream &stream, VisualizationDescription::Color &c){
      stream >> c.rgba;
      return stream;
    }
    
    inline void VisualizationDescription::text(icl32f x, icl32f y, const std::string &text){
      addPart('t',VisualizationDescription::Text(Point32f(x,y),text));
    }
    
    inline void VisualizationDescription::text(const Point32f &pos, const std::string &text){
      addPart('t',VisualizationDescription::Text(pos,text));
    }
    
    inline void VisualizationDescription::color(icl8u r, icl8u g, icl8u b){
      addPart('c',VisualizationDescription::Color(r,g,b));
    }
    
    inline void VisualizationDescription::color(icl8u r, icl8u g, icl8u b, icl8u a){
      addPart('c',VisualizationDescription::Color(r,g,b,a));
    }
    
    inline void VisualizationDescription::fill(icl8u r, icl8u g, icl8u b){
      addPart('f',VisualizationDescription::Color(r,g,b));
    }
    
    inline void VisualizationDescription::fill(icl8u r, icl8u g, icl8u b, icl8u a){
      addPart('f',VisualizationDescription::Color(r,g,b,a));
    }
  }
}