gnuplot_i.hpp

 
 
#ifndef _GNUPLOT_PIPES_H_
#define _GNUPLOT_PIPES_H_
 
 
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>              // for std::ostringstream
#include <stdexcept>
#include <cstdio>
#include <cstdlib>              // for getenv()
#include <list>                 // for std::list
 
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)
//defined for 32 and 64-bit environments
 #include <io.h>                // for _access(), _mktemp()
 #define GP_MAX_TMP_FILES  27   // 27 temporary files it's Microsoft restriction
#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)
//all UNIX-like OSs (Linux, *BSD, MacOSX, Solaris, ...)
#include <unistd.h>            // for access(), mkstemp()
#define GP_MAX_TMP_FILES  64
#else
#error unsupported or unknown operating system
#endif
 
//declare classes in global namespace
 
 
class GnuplotException : public std::runtime_error
{
public:
    GnuplotException(const std::string &msg) : std::runtime_error(msg){}
};
 
 
 
class Gnuplot
{
private:
 
    //----------------------------------------------------------------------------------
    // member data
    FILE                    *gnucmd;
    bool                     valid;
    bool                     two_dim;
    int                      nplots;
    std::string              pstyle;
    std::string              smooth;
    std::vector<std::string> tmpfile_list;
 
    //----------------------------------------------------------------------------------
    // static data
    static int               tmpfile_num;
    static std::string       m_sGNUPlotFileName;
    static std::string       m_sGNUPlotPath;
    static std::string       terminal_std;
 
    //----------------------------------------------------------------------------------
    // member functions (auxiliary functions)
    // ---------------------------------------------------
    // ---------------------------------------------------
    void           init();
    // ---------------------------------------------------
    // ---------------------------------------------------
    std::string    create_tmpfile(std::ofstream &tmp);
 
    //----------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------
    static bool    get_program_path();
 
    // ---------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------
    bool file_available(const std::string &filename);
 
    // ---------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------
    static bool    file_exists(const std::string &filename, int mode=0);
 
public:
 
    // ----------------------------------------------------------------------------
    // ----------------------------------------------------------------------------
    static bool set_GNUPlotPath(const std::string &path);
 
 
    // ----------------------------------------------------------------------------
    // ----------------------------------------------------------------------------
    static void set_terminal_std(const std::string &type);
 
    //-----------------------------------------------------------------------------
    // constructors
    // ----------------------------------------------------------------------------
 
 
    Gnuplot(const std::string &style = "points");
 
    Gnuplot(const std::vector<double> &x,
            const std::string &title = "",
            const std::string &style = "points",
            const std::string &labelx = "x",
            const std::string &labely = "y");
 
    Gnuplot(const std::vector<double> &x,
            const std::vector<double> &y,
            const std::string &title = "",
            const std::string &style = "points",
            const std::string &labelx = "x",
            const std::string &labely = "y");
 
    Gnuplot(const std::vector<double> &x,
            const std::vector<double> &y,
            const std::vector<double> &z,
            const std::string &title = "",
            const std::string &style = "points",
            const std::string &labelx = "x",
            const std::string &labely = "y",
            const std::string &labelz = "z");
 
    ~Gnuplot();
 
 
    //----------------------------------------------------------------------------------
 
    Gnuplot& cmd(const std::string &cmdstr);
    // ---------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------
    inline Gnuplot& operator<<(const std::string &cmdstr){
        cmd(cmdstr);
        return(*this);
    }
 
 
 
    //----------------------------------------------------------------------------------
    // show on screen or write to file
 
    Gnuplot& showonscreen(); // window output is set by default (win/x11/aqua)
 
    Gnuplot& savetops(const std::string &filename = "gnuplot_output");
 
 
    //----------------------------------------------------------------------------------
    // set and unset
 
    Gnuplot& set_style(const std::string &stylestr = "points");
 
    Gnuplot& set_smooth(const std::string &stylestr = "csplines");
 
    // ----------------------------------------------------------------------
    // ----------------------------------------------------------------------
    inline Gnuplot& unset_smooth(){ smooth = ""; return *this;};
 
 
    Gnuplot& set_pointsize(const double pointsize = 1.0);
 
    inline Gnuplot& set_grid()  {cmd("set grid");return *this;};
    inline Gnuplot& unset_grid(){cmd("unset grid");return *this;};
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& set_multiplot(){cmd("set multiplot") ;return *this;};
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& unset_multiplot(){cmd("unset multiplot");return *this;};
 
 
 
    Gnuplot& set_samples(const int samples = 100);
    Gnuplot& set_isosamples(const int isolines = 10);
 
    // --------------------------------------------------------------------------
    // --------------------------------------------------------------------------
    Gnuplot& set_hidden3d(){cmd("set hidden3d");return *this;};
 
    // ---------------------------------------------------------------------------
    // ---------------------------------------------------------------------------
    inline Gnuplot& unset_hidden3d(){cmd("unset hidden3d"); return *this;};
 
    Gnuplot& set_contour(const std::string &position = "base");
    // --------------------------------------------------------------------------
    // ------------------------------------------------------------------
    inline Gnuplot& unset_contour(){cmd("unset contour");return *this;};
 
    // ------------------------------------------------------------
    // ------------------------------------------------------------------
    inline Gnuplot& set_surface(){cmd("set surface");return *this;};
 
    // ----------------------------------------------------------
    // ------------------------------------------------------------------
    inline Gnuplot& unset_surface(){cmd("unset surface"); return *this;}
 
 
    Gnuplot& set_legend(const std::string &position = "default");
 
    // ------------------------------------------------------------------
    // ------------------------------------------------------------------
    inline Gnuplot& unset_legend(){cmd("unset key"); return *this;}
 
    // -----------------------------------------------------------------------
    // -----------------------------------------------------------------------
    inline Gnuplot& set_title(const std::string &title = "")
    {
        std::string cmdstr;
        cmdstr = "set title \"";
        cmdstr+=title;
        cmdstr+="\"";
        *this<<cmdstr;
        return *this;
    }
 
    //----------------------------------------------------------------------------------
    // ---------------------------------------------------------------------------------
    inline Gnuplot& unset_title(){this->set_title();return *this;}
 
 
    Gnuplot& set_ylabel(const std::string &label = "x");
    Gnuplot& set_xlabel(const std::string &label = "y");
    Gnuplot& set_zlabel(const std::string &label = "z");
 
    Gnuplot& set_xrange(const double iFrom,
                        const double iTo);
    Gnuplot& set_yrange(const double iFrom,
                        const double iTo);
    Gnuplot& set_zrange(const double iFrom,
                        const double iTo);
    // -----------------------------------------------
    inline Gnuplot& set_xautoscale(){cmd("set xrange restore");cmd("set autoscale x");return *this;};
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& set_yautoscale(){cmd("set yrange restore");cmd("set autoscale y");return *this;};
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& set_zautoscale(){cmd("set zrange restore");cmd("set autoscale z");return *this;};
 
 
    Gnuplot& set_xlogscale(const double base = 10);
    Gnuplot& set_ylogscale(const double base = 10);
    Gnuplot& set_zlogscale(const double base = 10);
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& unset_xlogscale(){cmd("unset logscale x"); return *this;};
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& unset_ylogscale(){cmd("unset logscale y"); return *this;};
 
    // -----------------------------------------------
    // -----------------------------------------------
    inline Gnuplot& unset_zlogscale(){cmd("unset logscale z"); return *this;};
 
 
    Gnuplot& set_cbrange(const double iFrom, const double iTo);
 
 
    //----------------------------------------------------------------------------------
    // plot
 
    Gnuplot& plotfile_x(const std::string &filename,
                        const unsigned int column = 1,
                        const std::string &title = "");
    template<typename X>
    Gnuplot& plot_x(const X& x, const std::string &title = ""){
        if (x.size() == 0)
        {
            throw GnuplotException("std::vector too small");
            return *this;
        }
 
        std::ofstream tmp;
        std::string name = create_tmpfile(tmp);
        if (name == "")
            return *this;
 
        //
        // write the data to file
        //
        for (unsigned int i = 0; i < x.size(); i++)
            tmp << x[i] << std::endl;
 
        tmp.flush();
        tmp.close();
 
 
        plotfile_x(name, 1, title);
 
        return *this;
    }
 
 
    Gnuplot& plotfile_xy(const std::string &filename,
                         const unsigned int column_x = 1,
                         const unsigned int column_y = 2,
                         const std::string &title = "");
    template<typename X, typename Y>
    Gnuplot& plot_xy(const X& x, const Y& y, const std::string &title = "")
    {
        if (x.size() == 0 || y.size() == 0)
        {
            throw GnuplotException("std::vectors too small");
            return *this;
        }
 
        if (x.size() != y.size())
        {
            throw GnuplotException("Length of the std::vectors differs");
            return *this;
        }
 
 
        std::ofstream tmp;
        std::string name = create_tmpfile(tmp);
        if (name == "")
            return *this;
 
        //
        // write the data to file
        //
        for (unsigned int i = 0; i < x.size(); i++)
            tmp << x[i] << " " << y[i] << std::endl;
 
        tmp.flush();
        tmp.close();
 
 
        plotfile_xy(name, 1, 2, title);
 
        return *this;
    }
 
 
 
    Gnuplot& plotfile_xy_err(const std::string &filename,
                             const unsigned int column_x  = 1,
                             const unsigned int column_y  = 2,
                             const unsigned int column_dy = 3,
                             const std::string &title = "");
    template<typename X, typename Y, typename E>
    Gnuplot& plot_xy_err(const X &x, const Y &y, const E &dy,
                         const std::string &title = ""){
        if (x.size() == 0 || y.size() == 0 || dy.size() == 0)
        {
            throw GnuplotException("std::vectors too small");
            return *this;
        }
 
        if (x.size() != y.size() || y.size() != dy.size())
        {
            throw GnuplotException("Length of the std::vectors differs");
            return *this;
        }
 
 
        std::ofstream tmp;
        std::string name = create_tmpfile(tmp);
        if (name == "")
            return *this;
 
        //
        // write the data to file
        //
        for (unsigned int i = 0; i < x.size(); i++)
            tmp << x[i] << " " << y[i] << " " << dy[i] << std::endl;
 
        tmp.flush();
        tmp.close();
 
 
        // Do the actual plot
        plotfile_xy_err(name, 1, 2, 3, title);
 
        return *this;
    }
 
 
    Gnuplot& plotfile_xyz(const std::string &filename,
                          const unsigned int column_x = 1,
                          const unsigned int column_y = 2,
                          const unsigned int column_z = 3,
                          const std::string &title = "");
    template<typename X, typename Y, typename Z>
    Gnuplot& plot_xyz(const X &x,
                      const Y &y,
                      const Z &z,
                      const std::string &title = ""){
        if (x.size() == 0 || y.size() == 0 || z.size() == 0)
        {
            throw GnuplotException("std::vectors too small");
            return *this;
        }
 
        if (x.size() != y.size() || x.size() != z.size())
        {
            throw GnuplotException("Length of the std::vectors differs");
            return *this;
        }
 
 
        std::ofstream tmp;
        std::string name = create_tmpfile(tmp);
        if (name == "")
            return *this;
 
        //
        // write the data to file
        //
        for (unsigned int i = 0; i < x.size(); i++)
            tmp << x[i] << " " << y[i] << " " << z[i] <<std::endl;
 
        tmp.flush();
        tmp.close();
 
 
        plotfile_xyz(name, 1, 2, 3, title);
 
        return *this;
    }
 
 
    Gnuplot& plot_slope(const double a,
                        const double b,
                        const std::string &title = "");
 
 
    Gnuplot& plot_equation(const std::string &equation,
                           const std::string &title = "");
 
    Gnuplot& plot_equation3d(const std::string &equation,
                             const std::string &title = "");
 
 
    Gnuplot& plot_image(const unsigned char *ucPicBuf,
                        const unsigned int iWidth,
                        const unsigned int iHeight,
                        const std::string &title = "");
 
 
    //----------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------
    inline Gnuplot& replot(void){if (nplots > 0) cmd("replot");return *this;};
 
    Gnuplot& reset_plot();
 
    Gnuplot& reset_all();
 
    void remove_tmpfiles();
 
    // -------------------------------------------------------------------
    // -------------------------------------------------------------------
    inline bool is_valid(){return(valid);};
 
};
template <typename Container>
void stringtok (Container &container,
                std::string const &in,
                const char * const delimiters = " \t\n")
{
    const std::string::size_type len = in.length();
    std::string::size_type i = 0;
 
    while ( i < len )
    {
        // eat leading whitespace
        i = in.find_first_not_of (delimiters, i);
 
        if (i == std::string::npos)
            return;   // nothing left but white space
 
        // find the end of the token
        std::string::size_type j = in.find_first_of (delimiters, i);
 
        // push token
        if (j == std::string::npos)
        {
            container.push_back (in.substr(i));
            return;
        }
        else
            container.push_back (in.substr(i, j-i));
 
        // set up for next loop
        i = j + 1;
    }
 
    return;
}
#endif