/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/sg/vec2plot

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_sg_vec2plot
#define inlib_sg_vec2plot

// Inheritance :
#include "plottable"

#include "../smanip"
#include "../vmanip"
#include "../mnmx"

namespace inlib {
namespace sg {

template <class T>
class xy2plot : public virtual points2D {
public: //plottable
  virtual plottable* copy() const {return new xy2plot(*this);}
  virtual bool is_valid() const {return true;}
  virtual std::string name(){return m_name;}
  virtual void set_name(const std::string& a_s) {m_name = a_s;}
  virtual std::string title(){return "";}
  virtual std::string legend(){return m_legend;}
  virtual void set_legend(const std::string& a_s) {m_legend = a_s;}

  virtual std::string infos(const std::string& a_opts){
    std::string f_lf("\n");
    std::string sinfos;
    std::vector<std::string> words;
    inlib::words(a_opts," ",false,words);
    std::vector<std::string>::const_iterator it;
  
    for(it=words.begin();it!=words.end();++it) {
      if(((*it)=="name") && m_name.size()) {
        if(sinfos.size()) sinfos += f_lf;
        sinfos += "Name\n";
        sinfos += m_name;
  
      } else if((*it)=="entries") {
        if(sinfos.size()) sinfos += f_lf;
        sinfos += "Entries\n";
        sinfos += inlib::to<int>
          (inlib::mn<unsigned int>(m_x.size(),m_y.size()));
  
      }
    }
  
    return sinfos;
  }  
public: //points2D
  virtual float x_axis_min() const {return float(m_x_min);}
  virtual float x_axis_max() const {return float(m_x_max);}
  virtual float y_axis_min() const {return float(m_y_min);}
  virtual float y_axis_max() const {return float(m_y_max);}

  virtual unsigned int points() const {
    return inlib::mn<unsigned int>(m_x.size(),m_y.size());
  }
  virtual bool ith_point(unsigned int a_index,float& a_x,float& a_y) const {
    if(a_index>=m_x.size()) {a_x = T();a_y = T();return false;}
    if(a_index>=m_y.size()) {a_x = T();a_y = T();return false;}
    a_x = m_x[a_index];
    a_y = m_y[a_index];
    return true;
  }
public:
  typedef typename std::vector<T> data_t;
public:
  xy2plot(const data_t& a_x,const data_t& a_y)
  :m_x(a_x)
  ,m_y(a_y)
  {
    inlib::minimum<T>(a_x,m_x_min);
    inlib::maximum<T>(a_x,m_x_max);

    inlib::minimum<T>(a_y,m_y_min);
    inlib::maximum<T>(a_y,m_y_max);
  }
  virtual ~xy2plot(){}
protected:
  xy2plot(const xy2plot& a_from)
  :plottable(a_from),points2D(a_from)
  ,m_x(a_from.m_x)
  ,m_y(a_from.m_y)
  ,m_name(a_from.m_name)
  ,m_legend(a_from.m_legend)
  ,m_x_min(a_from.m_x_min)
  ,m_x_max(a_from.m_x_max)
  ,m_y_min(a_from.m_y_min)
  ,m_y_max(a_from.m_y_max)
  {}  
private:
  xy2plot& operator=(const xy2plot&){return *this;}
private:
  const data_t& m_x;
  const data_t& m_y;
  std::string m_name;
  std::string m_legend;
  T m_x_min;
  T m_x_max;
  T m_y_min;
  T m_y_max;
private:
  static void check_instantiation() {
    std::vector< std::pair<float,float> > data;
    xy2plot<float> dummy(data);
  }
};

}}

#endif