GraphicsInterface.hpp

// This file is part of the imaging2 class library.
//
// University of Innsbruck, Infmath Imaging, 2009.
// http://infmath.uibk.ac.at
//
// All rights reserved.


#ifndef GRAPHICS_GRAPHICSINTERFACE_H
#define GRAPHICS_GRAPHICSINTERFACE_H

#include <image/Color.hpp>
#include <image/Image.hpp>
#include <spline/Bspline.hpp>

namespace imaging
{
  class OpenGlViewer;
  class DummyGraphics;
  
  class GraphicsInterface
  {
  public:
  
    class CommandInterface
    {
    public:
      virtual ~CommandInterface() {}
    };
    
    class FlushCommand : public CommandInterface
    {};
    
    class ResetCommand : public CommandInterface
    {};

    class set_group : public CommandInterface
    {
      size_t _group_id;
      
    public:
      set_group(size_t group_id) : _group_id(group_id) {}
      
      size_t group_id() const { return _group_id; }
      
      void group_id(size_t id) { _group_id = id; }
    };


    class offset_z_layer : public CommandInterface
    {
      int _offset;
      
    public:
      offset_z_layer(int offset) : _offset(offset) {}
      
      int offset() const { return _offset; }
      
      void offset(size_t offset) { _offset = offset; }
    };

    class translate : public CommandInterface
    {
      friend class GraphicsInterface;
      
      ublas::fixed_vector<float_t, 2> _translation;
    public:
      translate(const ublas::fixed_vector<float_t, 2> & translation) : _translation(translation) {}
      const ublas::fixed_vector<float_t, 2> & translation() const { return _translation; }
      
      void translation(const ublas::fixed_vector<float_t, 2> & translation) { _translation = translation; }
    };
    
    class set_color : public CommandInterface
    {
      friend class GraphicsInterface;
      
      Color _color;
    public:
      set_color(const Color & color) : _color(color) {}
      
      const Color & color() const { return _color; }
      
      void color(const Color & color) { _color = color; }
    };

    class set_line_width : public CommandInterface
    {
      friend class GraphicsInterface;
      
      float_t _line_width;
    public:
      set_line_width(float_t line_width) : _line_width(line_width) {}
      
      float_t line_width() const { return _line_width; }
      
      void line_width(float_t width) { _line_width = width; }
    };
    
    class StreamStatus : public set_group, public offset_z_layer, public set_color, public set_line_width, public translate
    {

    public:
      StreamStatus() : set_group(0), offset_z_layer(0), set_color(Color::BLACK), set_line_width(1.0), translate(ublas::fixed_vector<float_t, 2>(0.0, 0.0)) {}
      
      StreamStatus(size_t group_id, int offset, const Color & color, float_t line_width, const ublas::fixed_vector<float_t, 2> & translation) : set_group(group_id), offset_z_layer(offset), set_color(color), set_line_width(line_width), translate(translation) {}
    };
    
  public:
    
    static const FlushCommand flush;
    
    static const ResetCommand reset_group;
    
    virtual ~GraphicsInterface() {}
     
    virtual void clear() = 0;
                              
    virtual void set_coordinates(const ublas::fixed_vector<float_t, 2> & lower_left, const ublas::fixed_vector<float_t, 2> & upper_right) = 0;

    void line_segment(const ublas::fixed_vector<float_t, 2> & v_0, const ublas::fixed_vector<float_t, 2> & v_1);
    
    void arrow(const ublas::fixed_vector<float_t, 2> & starting_point, const ublas::fixed_vector<float_t, 2> & direction) ;
    
    void quadrangle(const ublas::fixed_vector<float_t, 2> & v_0, const ublas::fixed_vector<float_t, 2> & v_1, const ublas::fixed_vector<float_t, 2> & v_2, const ublas::fixed_vector<float_t, 2> & v_3);
    
    void triangle(const ublas::fixed_vector<float_t, 2> & v_0, const ublas::fixed_vector<float_t, 2> & v_1, const ublas::fixed_vector<float_t, 2> & v_2);
    
    virtual void circle(const ublas::fixed_vector<float_t, 2> & center, float_t radius) = 0;

    virtual void polygon(const std::vector< ublas::fixed_vector<float_t, 2> > & vertices) = 0;

    virtual void fill_polygon(const std::vector< ublas::fixed_vector<float_t, 2> > & vertices) = 0;
    
    virtual void polyline(const std::vector< ublas::fixed_vector<float_t, 2> > & vertices) = 0;
   
    virtual void vertex(const ublas::fixed_vector<float_t, 2> & vertex) = 0;
    
    virtual void image(const ColorImage2d & image, const ublas::fixed_vector<float_t, 2> x_interval, const ublas::fixed_vector<float_t, 2> y_interval) = 0;
    
    virtual void spline_curve(const Bspline< ublas::fixed_vector<float_t, 2> > & spline_curve) = 0;

    virtual GraphicsInterface & operator<<(const CommandInterface & command) = 0;
    
    virtual GraphicsInterface & operator<<(const StreamStatus & status) = 0;

    virtual const StreamStatus & get_stream_status() = 0;
  };
}

#endif

---