gnuplot.h

/**************************************************************************
 * Copyright (c) 2004-2011 T. M. Murali                                   *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm is free software: you can redistribute it and/or modify       *
 * it under the terms of the GNU General Public License as published by   *
 * the Free Software Foundation, either version 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm 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 General Public License for more details.                           *
 *                                                                        *
 * You should have received a copy of the GNU General Public License      *
 * along with Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

#include <fstream>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>

using namespace std;

enum GnuplotLineStyleType { GNUPLOT_LINESTYLE_POINTS = 0,
                            GNUPLOT_LINESTYLE_LINES,
                            GNUPLOT_LINESTYLE_LINESPOINTS,
                            GNUPLOT_LINESTYLE_IMPULSES,
                            GNUPLOT_LINESTYLE_DOTS,
                            GNUPLOT_LINESTYLE_STEPS,
                            GNUPLOT_LINESTYLE_ERRORBARS,
                            GNUPLOT_LINESTYLE_BOXES,
                            GNUPLOT_LINESTYLE_BOXERRORBARS
};

enum GnuplotTerminalType { GNUPLOT_TERMINAL_FIG,
                           GNUPLOT_TERMINAL_PDF,
                           GNUPLOT_TERMINAL_PNG,
                           GNUPLOT_TERMINAL_POSTSCRIPT
};

class GnuplotFileGenerator;

class GnuplotDataFile
{
  friend class GnuplotFileGenerator;
  
private:
  string dataFile;
  unsigned int index;
  string title;
  
public:
  GnuplotDataFile(string f, unsigned int i = 0, string t = "")
      : dataFile(f), index(i), title(t)
    {}
  

  virtual ~GnuplotDataFile()
    {}
  
};


class GnuplotFileGenerator
{
private:

  // the file containing gnuplot commands.
  string _gnuplotCommandsFile;
  // _dataFileNames must be a vector because i may add the same file name but with different indices.
  vector< GnuplotDataFile > _dataFileNames;
  map< string, GnuplotLineStyleType >_dataFileLineStyles;
//  map< string, string >_dataFileTitles;
  string plotTitle;
  bool time;
  bool logscale;
  
  set< string > _functions;

  GnuplotLineStyleType _lineStyle;
  
//   bool lines;
//   bool points;
//   bool linespoints;
//   bool impulses;
//   bool dots;
//   bool steps;
//   bool errorbars;
//   bool boxes;
//   bool boxerrorbars;

  string xlabel;
  string ylabel;
  string zlabel;
  bool border;
  bool key;
  bool zeroaxis;
  bool grid;
  bool dgrid3d;
  bool xtics;
  bool ytics;
  bool color;
  bool solid;

  GnuplotTerminalType _terminal;
//   bool terminal_postscript;
//   bool terminal_png;
//   bool terminal_gif;
  bool plot3d;
  bool contour_base;
  bool contour_surface;
  bool contour_both;
  bool cntrparam_linear;
  bool cntrparam_cubicspline;
  bool cntrparam_bspline;
  int x1;
  int x2;
  int y1;
  int y2;
  int use1;
  int use2;
  int use3;
  
public:

  GnuplotFileGenerator()
    {
//      _dataFileNames = set<string>();
      plotTitle = "";
      time = false;
      logscale = false;
      _lineStyle = GNUPLOT_LINESTYLE_POINTS;
//       lines = true;
//       points = false;
//       linespoints = false;
//       impulses = false;
//       dots = false;
//       steps = false;
//       errorbars = false;
//       boxes = false;
//       boxerrorbars = false;
      xlabel = "";
      ylabel = "";
      zlabel = "";
      border = true;
      key = true;
      zeroaxis = true;
      grid = true;
      dgrid3d = false;
      xtics = true;
      ytics = true;
      color = true;
      solid = false;

      _terminal = GNUPLOT_TERMINAL_PNG;
//       terminal_postscript = true;
//       terminal_png = false;
//       terminal_gif = false;
      plot3d = false;
      contour_base = false;
      contour_surface = false;
      contour_both = false;
      cntrparam_linear = false;
      cntrparam_cubicspline = false;
      cntrparam_bspline = false;
      x1 = 0;
      x2 = 0;
      y1 = 0;
      y2 = 0;
      use1 = 0;
      use2 = 0;
      use3 = 0;

    }
  ~GnuplotFileGenerator(){}

  void addDataFile(string file, unsigned int index = 0, string title = "")
    {
      _dataFileNames.push_back(GnuplotDataFile(file, index, title));
    }
  
        /*
         * Add a function.
         * 
         * \param[in] funciton, the function to plot.
         */
        void addFunction(string function)
        {
                _functions.insert(function);
        }
  
  void setColumnsToPlot(int c1, int c2, int c3 = 0)
    {
      use1 = c1;
      use2 = c2;
      use3 = c3;
    }

  void setLabels(string xl = "", string yl = "",string zl = "")
    {
      xlabel = xl;
      ylabel = yl;
      zlabel = zl;
    }

  void setGnuplotFileName(string file)
    {
      _gnuplotCommandsFile = file;
    }
  
  
  void setLinestyle(GnuplotLineStyleType style, string fileName = "")
    {
      if ("" == fileName)
        _lineStyle = style;
      else
        _dataFileLineStyles[fileName] = style;
    }
  
  void setPlot3d(bool set)
    {
      plot3d = set;
    }

  void setPlotTitle(string t)
    {
      plotTitle = t;
    }

  void setXrange(int X1, int X2)
    {
      x1 = X1;
      x2 = X2;
    }
  void setYrange(int Y1, int Y2)
    {
      y1 = Y1;
      y2 = Y2;
    }

  void setTerminal(GnuplotTerminalType terminal)
    {
      _terminal = terminal;
    }
  
  void setContour_base(void)
    {
      if(contour_surface)contour_surface = false;
      if(contour_both)contour_both = false;
      
      contour_base = true;
    }
  void setContour_surface(void)
    {
      if(contour_base)contour_base = false;
      if(contour_both)contour_both = false;
      
      contour_surface = true;
    }
  void setContour_both(void)
    {
      if(contour_surface)contour_surface = false;
      if(contour_base)contour_base = false;
      
      contour_both = true;
    } 
  
  
  void setCntrparam_linear(void)
    {
      if(cntrparam_cubicspline)cntrparam_cubicspline = false;
      if(cntrparam_bspline)cntrparam_bspline = false;
      
      cntrparam_linear = true;
    }
  void setCntrparam_cubicspline(void)
    {
      if(cntrparam_linear)cntrparam_linear = false;
      if(cntrparam_bspline)cntrparam_bspline = false;
      
      cntrparam_cubicspline = true;
    }
  void setCntrparam_bspline(void)
    {
      if(cntrparam_cubicspline)cntrparam_cubicspline = false;
      if(cntrparam_linear)cntrparam_linear = false;
      
      cntrparam_bspline = true;
    }

  //turning on and off certain parameters.
  void turnon_grid(void)
    {
      grid = true;
    }
  void turnoff_grid(void)
    {
      grid = false;
    }
  void turnon_dgrid3d(void)
    {
      dgrid3d = true;
    }
  void turnoff_dgrid3d(void)
    {
      dgrid3d = false;
    }
  void turnon_key(void)
    {
      key = true;
    }
  void turnoff_key(void)
    {
      key = false;
        }
  void turnon_border(void)
    {
      border = true;
    }
  void turnoff_border(void)
    {
      border = false;
    }
  void turnon_xtics(void)
    {
      xtics = true;
    }
  void turnoff_xtics(void)
    {
      xtics = false;
    }
  void turnon_ytics(void)
    {
      ytics = true;
    }
  void turnoff_ytics(void)
    {
      ytics = false;
    }
  void turnon_logscale(void)
    {
      logscale = true;
    }
  void turnoff_logscale(void)
    {
      logscale = false;
    }
  void turnon_time(void)
    {
      time = true;
    }
  void turnoff_time(void)
    {
      time = false;
    }
  void turnon_zeroaxis(void)
    {
      zeroaxis = true;
    }
  void turnoff_zeroaxis(void)
    {
      zeroaxis = false;
    }
  void turnon_Color(void)
    {
      color = true;
    }
  void turnoff_Color(void)
    {
      color = false;
    }
  void turnon_Solid(void)
    {
      solid = true;
    }
  void turnoff_Solid(void)
    {
      solid = false;
    }   
    
  void generate()
    {
      generateFile();
      generatePlot();
    }
  

  void generateFile(void)
    {
      ofstream gfile;
      if (_dataFileNames.empty())
        {
          cerr << "No data files to plot! Did you forget to specify data files with the GnuplotFileGenerator::addDataFile() method?" << endl;
          return;
        }
      vector< GnuplotDataFile >::iterator fitr;
      map< string, GnuplotLineStyleType >::iterator sitr;
      if ("" == _gnuplotCommandsFile)
        {
          // use the concatenation of all the data file names.
          for (fitr = _dataFileNames.begin(); fitr != _dataFileNames.end(); fitr++)
            {
              if (fitr != _dataFileNames.begin())
                _gnuplotCommandsFile += "-";
              _gnuplotCommandsFile += fitr->dataFile;
            }
        }
      string _gnuplotCommandsFileBase = _gnuplotCommandsFile;
      _gnuplotCommandsFile += ".gp";
      gfile.open(_gnuplotCommandsFile.c_str());
      
      if(!gfile.is_open())
        return;
      pair< string, string > terminal = _getTerminalString(_terminal);

      gfile<<"set output \""<< _gnuplotCommandsFileBase << terminal.second << "\"" << endl;
      gfile<<"set terminal " << terminal.first << endl;
              
//       if(color) gfile<<" color\n";
//       else {
        if(solid) gfile<<" solid\n";
        else gfile<<"\n";
//      } 
      gfile<<"set autoscale x\n";
      gfile<<"set autoscale y\n";
      
      if(x1!=0||x2!=0)
        gfile<<"set xrange ["<<x1<<":"<<x2<<"]";
      if(y1!=0||y2!=0)
        gfile<<"set yrange ["<<y1<<":"<<y2<<"]";
      
      if(logscale)gfile<<"set logscale\n";
      else gfile<<"set nologscale\n";
      
      if(grid)gfile<<"set grid\n";
      else gfile<<"set nogrid\n";
      
      if(dgrid3d)gfile<<"set dgrid3d\n";
      else gfile<<"set nodgrid3d\n";
      
      if(border)gfile<<"set border\n";
      else gfile<<"set noborder\n";
      
      if(key)gfile<<"set key\n";
      else gfile<<"set nokey\n";
      
      if(xtics)gfile<<"set xtics\n";
      else gfile<<"set noxtics\n";
      
      if(ytics)gfile<<"set ytics\n";
      else gfile<<"set noytics\n";
      
      if(zeroaxis)gfile<<"set zeroaxis\n";
      else gfile<<"set nozeroaxis\n";
      
      if(time)gfile<<"set time\n";
      
      if(contour_base)gfile<<"set contour\n";
      if(contour_surface)gfile<<"set contour surface\n";
      if(contour_both)gfile<<"set contour both\n";
      
      if(cntrparam_cubicspline)gfile<<"set cntrparam cubicspline\n";
      if(cntrparam_bspline)gfile<<"set cntrparam bspline\n";
      if(cntrparam_linear)gfile<<"set cntrparam linear\n";
      
              
              
      if(plotTitle !="")gfile<<"set title \""<<plotTitle<<"\"\n";
      
      if(xlabel!="")gfile<<"set xlabel \""<<xlabel<<"\"\n";
      if(ylabel!="")gfile<<"set ylabel \""<<ylabel<<"\"\n";
      if(zlabel!="")gfile<<"set zlabel \""<<zlabel<<"\"\n";

      gfile <<"set data style "
            << _getLineStyleString(_lineStyle) <<"\n";
            
      string plotCommand;
      
      if(plot3d)
        {
          plotCommand = "splot ";
        }
      else
        {
          plotCommand = "plot ";
        }
      // print the plot command.
      gfile << plotCommand;
      map< string, string >::iterator titr;
      for (fitr = _dataFileNames.begin(); fitr != _dataFileNames.end(); fitr++)
        {
          if (fitr != _dataFileNames.begin())
            gfile << ", ";
          gfile << "\"" << fitr->dataFile <<"\"";
          gfile << " index " << fitr->index << " ";
          if(use1&&use2)gfile<<" using "<<use1<<":"<<use2;
          if(use3)gfile<<":"<<use3;
          gfile << " ";
          // print the title of this data file, if it exists. print after the using command.
//           titr = _dataFileTitles.find(fitr->dataFile);
//           if (_dataFileTitles.end() != titr)
          if ("" != fitr->title)
            gfile << " title \"" << fitr->title << "\" ";
          sitr = _dataFileLineStyles.find(fitr->dataFile);
          if (_dataFileLineStyles.end() != sitr)
            gfile << " with " << _getLineStyleString(sitr->second); 
       }
       
      // print plot commands for functions
      for (set< string >::iterator funitr = _functions.begin(); funitr != _functions.end(); funitr++)
      {
        if ((funitr != _functions.begin()) || (!_dataFileNames.empty()))
                gfile << ", ";
        gfile << *funitr << " with lines"; // TODO add style control for functions
      }
      
      gfile << endl;
      gfile.close();
    }

  void generatePlot()
    {
      string gnuplotCommand;
      gnuplotCommand = "gnuplot " + _gnuplotCommandsFile;
      int returnValue = system(gnuplotCommand.c_str());

    }
  
private:
  string _getLineStyleString(GnuplotLineStyleType style)
    {
      if (GNUPLOT_LINESTYLE_POINTS == style)
        return("points");
      if (GNUPLOT_LINESTYLE_LINES == style)
        return("lines");
      if (GNUPLOT_LINESTYLE_LINESPOINTS == style)
        return("linespoints");
      cerr << "Unknown Gnuplot line style " << style << endl;
      exit(-1);
    }
  
  pair< string, string > _getTerminalString(GnuplotTerminalType terminal)
    {
      if (GNUPLOT_TERMINAL_PDF == terminal)
        return(pair<string, string>(" pdf ", ".pdf"));
      if (GNUPLOT_TERMINAL_PNG == terminal)
        return(pair<string, string>(" png ", ".png"));
      if (GNUPLOT_TERMINAL_POSTSCRIPT == terminal)
//        return(pair<string, string>(" postscript color landscape ", ".ps"));
        return(pair<string, string>(" postscript color ", ".ps"));
      cerr << "Unknown Gnuplot terminal type " << terminal << endl;
      exit(-1);
    }
  

};