SeriesList.hpp

Go to the documentation of this file.

#pragma ident "$Id: SeriesList.hpp 1644 2009-01-27 19:26:14Z ckiesch $"


//============================================================================
//
//  This file is part of GPSTk, the GPS Toolkit.
//
//  The GPSTk is free software; you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation; either version 2.1 of the License, or
//  any later version.
//
//  The GPSTk is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with GPSTk; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//  
//  Copyright 2004, The University of Texas at Austin
//
//============================================================================

#ifndef VPLOT_SERIESLIST_H
#define VPLOT_SERIESLIST_H

#include <string>
#include <vector>
#include <cfloat>

#include "Frame.hpp"
#include "StrokeStyle.hpp"
#include "Marker.hpp"
#include "Text.hpp"
#include "TextStyle.hpp"
#include "Color.hpp"
#include "Line.hpp"
#include "GridLayout.hpp"

using namespace std;
using namespace vdraw;

namespace vplot
{
  class SeriesList
  {
    public:
      SeriesList() 
      {
      }

      ~SeriesList()
      {
      }

      void addSeries(std::string& title, vector< pair<double,double> >& points, StrokeStyle& ss)
      {
        Marker m = Marker::clear();
        addSeries(title,points,ss,m);
      }

      void addSeries(std::string& title, vector< pair<double,double> >& points, Marker& m)
      {
        StrokeStyle ss = StrokeStyle::clear();
        addSeries(title,points,ss,m);
      }

      void addSeries(std::string& title, vector< pair<double,double> >& points, StrokeStyle& ss, Marker& m)
      {
        titles.push_back(title);
        pointlists.push_back(points);
        styles.push_back(ss);
        markers.push_back(m);
      }

      bool setLastTitle(std::string& newtitle)
      {
        return setTitle(titles.size()-1,newtitle);
      }

      bool setTitle(unsigned int idx, std::string& newtitle)
      {
        if(idx>=titles.size())
          return false;          
        titles[idx]=newtitle;
        return true;
      }

      bool setLastStyle(StrokeStyle& ss)
      {
        return setStyle(styles.size()-1,ss);
      }

      bool setStyle(unsigned int idx, StrokeStyle& ss)
      {
        if(idx>=styles.size())
          return false; 
        styles[idx]=ss;
        return true;
      }

      bool setLastMarker(Marker& m)
      {
        return setMarker(markers.size()-1,m);
      }

      bool setMarker(unsigned int idx, Marker& m)
      {
        if(idx>=styles.size())
          return false; 
        markers[idx]=m;
        return true;
      }

      int getNumSeries() { return pointlists.size(); }

      std::string getTitle(int idx) { return titles[idx]; }

      StrokeStyle getStyle(int idx) { return styles[idx]; }

      Marker getMarker(int idx)     { return markers[idx]; }

      vector< pair<double,double> >& getPointList(int idx) { return pointlists[idx]; }

      void findMinMax(double& minX, double &maxX, double& minY, double& maxY);

      void drawInFrame(Frame& innerFrame, double minX, double maxX, double minY, double maxY);

      void drawLegend(Frame& frame, double pointsize, unsigned int columns = 1);

    protected:


    private:
      vector< string > titles;

      vector< vector< pair<double,double> > > pointlists;

      vector< StrokeStyle > styles;

      vector< Marker > markers;

      struct map_object
      {
        double multX,minX,multY,minY;
        map_object(double multX,double minX,double multY,double minY)
        {
          this->multX = multX;
          this->minX = minX;
          this->multY = multY;
          this->minY = minY;
        }
        void operator() (Point& p)
        {
          p.x() = multX*(p.x()-minX);
          p.y() = multY*(p.y()-minY);
        }
      };

      void drawLegendSegment(Frame& frame, double pointsize, 
          unsigned int begin, unsigned int n);

  };

}

#endif

---