gplot.h

Go to the documentation of this file.

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef SP_GPLOT_H
#define SP_GPLOT_H
#include <vector>
#include <typeinfo>
namespace sp
{

class gplot
{
private:
  FILE *gnucmd; 
  std::string term;
  int fig_ix;
  int plot_ix;

  struct plot_data_s {
    std::string label;
    std::string linespec;
  };

  std::vector<plot_data_s> plotlist;

  template <typename T1, typename T2> void plot_str2(const T1 &x, const T2 &y)
  {
    std::ostringstream tmp_s;
    std::string s;
    tmp_s << "$Dxy" << plot_ix << " << EOD \n";
    arma::uword Nelem = x.n_elem;
    for (arma::uword n = 0; n < Nelem; n++)
    {
      tmp_s << x(n) << " " << y(n);
      s = tmp_s.str();
      send2gp(s.c_str());
      tmp_s.str(""); // Clear buffer
    }
    send2gp("EOD");
  }

  template <typename T> std::string get_type(T x)
  {
    if (typeid(x) == typeid(int8_t))
      return "int8";
    if (typeid(x) == typeid(uint8_t))
      return "uint8";
    if (typeid(x) == typeid(int16_t))
      return "int16";
    if (typeid(x) == typeid(uint16_t))
      return "uint16";
    if (typeid(x) == typeid(int32_t))
      return "int32";
    if (typeid(x) == typeid(uint32_t))
      return "uint32";
    if (typeid(x) == typeid(int64_t))
      return "int64";
    if (typeid(x) == typeid(arma::sword))
      return "int64";
    if (typeid(x) == typeid(uint64_t))
      return "uint64";
    if (typeid(x) == typeid(arma::uword))
      return "uint64";
    if (typeid(x) == typeid(float))
      return "float32";
    if (typeid(x) == typeid(double))
      return "float64";
    err_handler("Unknown type");
  }

public:
  gplot()
  {
#if defined(_MSC_VER)
    gnucmd = _popen("gnuplot -persist 2> NUL", "wb");
    term   = "win";
//#elif defined(_APPLE_)
//            gnucmd = popen("gnuplot -persist &> /dev/null","w");
//#define term "aqua"
#else
    gnucmd = popen("gnuplot -persist", "w");
    term   = "x11";
#endif
    if (!gnucmd)
    {
      err_handler("Could not start gnuplot");
    }

    // Set global params
    plot_ix = 0;
    fig_ix  = 0;
    plotlist.clear();
  }

  ~gplot()
  {
#if defined(_MSC_VER)
    _pclose(gnucmd);
#else
    pclose(gnucmd);
#endif
  }

  void send2gp(const char *cmdstr)
  {
    std::string s_in(cmdstr);
    std::string tmp = s_in + "\n";
    std::fputs(tmp.c_str(), gnucmd);
    //                std::cout << tmp.c_str() << std::endl;
  }

  void flush_cmd_buf(void) { std::fflush(gnucmd); }

  void draw_now(void) { std::fflush(gnucmd); }

  void figure(const int fig)
  {
    fig_ix = fig;
    std::ostringstream tmp_s;
    tmp_s << "set term " << term << " " << fig;
    std::string s = tmp_s.str();
    send2gp(s.c_str());
    send2gp("reset");
  }

  void window(const int fig, const char *name, const int x, const int y,
              const int width, const int height)
  {
    fig_ix = fig;
    std::ostringstream tmp_s;
    tmp_s << "set term " << term << " " << fig << " title \"" << name
          << "\" position " << x << "," << y << " size " << width << ","
          << height;
    std::string s = tmp_s.str();
    send2gp(s.c_str());
    send2gp("reset");
  }

  void window(const char *name, const int x, const int y, const int width,
              const int height)
  {
    window(0, name, x, y, width, height);
  }

  void close_window(void)
  {
    std::ostringstream tmp_s;
    tmp_s << "set term " << term << " close";
    std::string s = tmp_s.str();
    send2gp(s.c_str());
    send2gp("reset");
  }

  void grid_on(void) { send2gp("set grid"); }

  void grid_off(void) { send2gp("unset grid"); }

  void xlabel(const char *label)
  {
    std::ostringstream tmp_s;
    tmp_s << "set xlabel \"" << label << "\" ";
    std::string s = tmp_s.str();
    send2gp(s.c_str());
  }

  void ylabel(const char *label)
  {
    std::ostringstream tmp_s;
    tmp_s << "set ylabel \"" << label << "\" ";
    std::string s = tmp_s.str();
    send2gp(s.c_str());
  }

  void label(const double &x, const double &y, const char *label)
  {
    std::ostringstream tmp_s;
    tmp_s << "set label \"" << label << "\" at " << x << "," << y;
    std::string s = tmp_s.str();
    send2gp(s.c_str());
  }

  void title(const char *name)
  {
    std::ostringstream tmp_s;
    tmp_s << "set title \"" << name << " \" ";
    std::string s = tmp_s.str();
    send2gp(s.c_str());
  }

  void xlim(const double xmin, const double xmax)
  {
    std::ostringstream tmp_s;
    tmp_s << "set xrange [" << xmin << ":" << xmax << "]";
    std::string s = tmp_s.str();
    send2gp(s.c_str());
  }

  void ylim(const double ymin, const double ymax)
  {
    std::ostringstream tmp_s;
    tmp_s << "set yrange [" << ymin << ":" << ymax << "]";
    std::string s = tmp_s.str();
    send2gp(s.c_str());
  }

  template <typename T1, typename T2>
  void plot_add(const T1 &x, const T2 &y, const std::string lb,
                const std::string ls = "lines")
  {
    plot_data_s pd;

    pd.linespec = ls;
    pd.label    = lb;

    plotlist.push_back(pd);
    plot_str2(x, y);
    plot_ix++;
  }

  template <typename T1>
  void plot_add(const T1 &y, const std::string lb,
                const std::string ls = "lines")
  {
    arma::vec x = arma::regspace(0, double(y.n_elem - 1));
    plot_data_s pd;

    pd.linespec = ls;
    pd.label    = lb;

    plotlist.push_back(pd);
    plot_str2(x, y);
    plot_ix++;
  }

  void plot_add_mat(const arma::mat &y)
  {
    arma::vec x = arma::regspace(0, double(y.n_cols - 1));
    plot_data_s pd;

    pd.linespec = "lines";
    pd.label    = "";
    for (arma::uword r = 0; r < y.n_rows; r++)
    {
      plotlist.push_back(pd);
      plot_str2(x, y.row(r));
      plot_ix++;
    }
  }

  void plot_add_mat(const arma::mat &y, const std::string p_lb)
  {
    arma::vec x = arma::regspace(0, double(y.n_cols - 1));
    plot_data_s pd;
    pd.linespec = "lines";

    for (arma::uword r = 0; r < y.n_rows; r++)
    {
      std::ostringstream tmp_s;
      tmp_s << p_lb << r;
      std::string s = tmp_s.str();
      pd.label      = s;
      plotlist.push_back(pd);
      plot_str2(x, y.row(r));
      plot_ix++;
    }
  }

  void plot_show(void)
  {
    std::ostringstream tmp_s;

    tmp_s << "plot $Dxy0 title \"" << plotlist[0].label << "\" with "
          << plotlist[0].linespec;
    for (int r = 1; r < plot_ix; r++)
    {
      tmp_s << " ,$Dxy" << r << " title \"" << plotlist[r].label << "\" with "
            << plotlist[r].linespec;
    }
    std::string s = tmp_s.str();
    send2gp(s.c_str());
    plotlist.clear();
    plot_ix = 0;
  }

  void plot_clear(void)
  {
    plotlist.clear();
    plot_ix = 0;
  }

  template <typename T>
  void fast_plot(const arma::Col<T> &x,
                 const std::string fmt_args = "with lines")
  {
    std::string fmt = get_type(x.at(0));
    std::string s;
    send2gp("unset key");

    s = "plot '-' binary format='%" + fmt + "' array=(" +
        std::to_string(x.n_elem) + ") " + fmt_args;
    send2gp(s.c_str());
    std::fwrite(x.memptr(), sizeof(x.at(0)), x.n_elem, gnucmd);
    flush_cmd_buf();
  }

  template <typename T>
  void fast_plot(const arma::Col<T> &x, const arma::Col<T> &y,
                 const std::string fmt_args = "with lines")
  {
    std::string fmt1 = get_type(x.at(0));
    std::string s;
    send2gp("unset key");
    const arma::uword N = x.n_elem;
    arma::Col<T> v(2 * N);
    for (arma::uword n = 0; n < N; n++)
    {
      v.at(2 * n)     = x.at(n);
      v.at(2 * n + 1) = y.at(n);
    }

    s = "plot '-' binary format='%" + fmt1 + "' record=(" +
        std::to_string(x.n_elem) + ") " + fmt_args;
    send2gp(s.c_str());
    std::fwrite(v.memptr(), sizeof(x.at(0)), v.n_elem, gnucmd);
    flush_cmd_buf();
  }

  template <typename T> void image(const arma::Mat<T> &x)
  {
    xlim(-0.5, x.n_cols - 0.5);
    ylim(x.n_rows - 0.5, -0.5);
    send2gp("unset key");
    std::string fmt = get_type(x.at(0));
    std::string s;

    s = "plot '-' binary array=(" + std::to_string(x.n_cols) + "," +
        std::to_string(x.n_rows) + ") scan=yx format='%" + fmt + "' w image";
    send2gp(s.c_str());
    std::fwrite(x.memptr(), sizeof(x.at(0)), x.n_elem, gnucmd);
    flush_cmd_buf();
  }

  template <typename T> void image(const arma::Cube<T> &x)
  {
    xlim(-0.5, x.n_cols - 0.5);
    ylim(x.n_rows - 0.5, -0.5);
    send2gp("unset key");
    std::string fmt = get_type(x.at(0));
    std::string s;

    // Conv cube to gnuplot rgb array
    arma::Cube<T> gp_im(arma::size(x));
    T *ptr = gp_im.memptr();
    for (arma::uword c = 0; c < x.n_cols; c++)
    {
      for (arma::uword r = 0; r < x.n_rows; r++)
      {
        *ptr++ = x.at(r, c, 0); // R
        *ptr++ = x.at(r, c, 1); // G
        *ptr++ = x.at(r, c, 2); // B
      }
    }

    s = "plot '-' binary array=(" + std::to_string(x.n_cols) + "," +
        std::to_string(x.n_rows) + ") scan=yx format='%" + fmt + "' w rgbimage";
    send2gp(s.c_str());
    std::fwrite(gp_im.memptr(), sizeof(x.at(0)), gp_im.n_elem, gnucmd);
    flush_cmd_buf();
  }

  template <typename T> void mesh(const arma::Mat<T> &x)
  {
    send2gp("unset key");
    send2gp("set hidden3d");
    std::string fmt = get_type(x.at(0));
    std::string s   = "splot '-' binary array=(" + std::to_string(x.n_cols) +
                    "," + std::to_string(x.n_rows) + ") scan=yx format='%" +
                    fmt + "' w lines";
    send2gp(s.c_str());
    std::fwrite(x.memptr(), sizeof(x.at(0)), x.n_elem, gnucmd);
    flush_cmd_buf();
  }

  template <typename T> void surf(const arma::Mat<T> &x)
  {
    send2gp("set pm3d");
    mesh(x);
  }

  void set_parula_line(void)
  {
    send2gp("set linetype 1 lc rgb '#0072bd' "); // blue
    send2gp("set linetype 2 lc rgb '#d95319' "); // orange
    send2gp("set linetype 3 lc rgb '#edb120' "); // yellow
    send2gp("set linetype 4 lc rgb '#7e2f8e' "); // purple
    send2gp("set linetype 5 lc rgb '#77ac30' "); // green
    send2gp("set linetype 6 lc rgb '#4dbeee' "); // light-blue
    send2gp("set linetype 7 lc rgb '#a2142f' "); // red
  }

  void set_jet_line(void)
  {
    send2gp("set linetype 1 lc rgb '#0000ff' "); // blue
    send2gp("set linetype 2 lc rgb '#007f00' "); // green
    send2gp("set linetype 3 lc rgb '#ff0000' "); // red
    send2gp("set linetype 4 lc rgb '#00bfbf' "); // cyan
    send2gp("set linetype 5 lc rgb '#bf00bf' "); // pink
    send2gp("set linetype 6 lc rgb '#bfbf00' "); // yellow
    send2gp("set linetype 7 lc rgb '#3f3f3f' "); // black
  }
  void set_set1_line(void)
  {
    send2gp("set linetype 1 lc rgb '#E41A1C' "); // red
    send2gp("set linetype 2 lc rgb '#377EB8' "); // blue
    send2gp("set linetype 3 lc rgb '#4DAF4A' "); // green
    send2gp("set linetype 4 lc rgb '#984EA3' "); // purple
    send2gp("set linetype 5 lc rgb '#FF7F00' "); // orange
    send2gp("set linetype 6 lc rgb '#FFFF33' "); // yellow
    send2gp("set linetype 7 lc rgb '#A65628' "); // brown
    send2gp("set linetype 8 lc rgb '#F781BF' "); // pink

    send2gp("set palette maxcolors 8");
    char str[] = "set palette defined ( \
                      0 '#E41A1C',\
                      1 '#377EB8',\
                      2 '#4DAF4A',\
                      3 '#984EA3',\
                      4 '#FF7F00',\
                      5 '#FFFF33',\
                      6 '#A65628',\
                      7 '#F781BF')";
    send2gp(str);
  }

  void set_jet_palette(void)
  {
    char str[] = "set palette defined ( \
                      0 '#000090',\
                      1 '#000fff',\
                      2 '#0090ff',\
                      3 '#0fffee',\
                      4 '#90ff70',\
                      5 '#ffee00',\
                      6 '#ff7000',\
                      7 '#ee0000',\
                      8 '#7f0000')";
    send2gp(str);
  }

  void set_parula_palette(void)
  {
    char str[] = "set palette defined (\
                      0 '#352a87',\
                      1 '#0363e1',\
                      2 '#1485d4',\
                      3 '#06a7c6',\
                      4 '#38b99e',\
                      5 '#92bf73',\
                      6 '#d9ba56',\
                      7 '#fcce2e',\
                      8 '#f9fb0e')";
    send2gp(str);
  }

  // See http://www.kennethmoreland.com/color-advice/
  void set_coolwarm_palette(void)
  {
    char str[] = "set palette defined (\
                      0 '#5548C1', \
                      1 '#7D87EF', \
                      2 '#A6B9FF', \
                      3 '#CDD7F0', \
                      4 '#EBD1C2', \
                      5 '#F3A889', \
                      6 '#DE6A53', \
                      7 '#B10127')";
    send2gp(str);
  }

  // See http://www.kennethmoreland.com/color-advice/
  void set_blackbody_palette(void)
  {
    char str[] = "set palette defined (\
                      0 '#000000', \
                      1 '#2B0F6B', \
                      2 '#5D00CB', \
                      3 '#C60074', \
                      4 '#EB533C', \
                      5 '#F59730', \
                      6 '#E9D839', \
                      7 '#FFFFFF')";
    send2gp(str);
  }

  void set_output(const char *name)
  {
    std::string name_s(name);
    size_t found = name_s.find_last_of(".");
    std::string ext;
    ext = name_s.substr(found + 1);
    std::ostringstream tmp_s;

    if (ext.compare("png") == 0)
    {
      tmp_s << "set terminal pngcairo enhanced font 'Verdana,10'";
    }
    else if (ext.compare("ps") == 0)
    {
      tmp_s << "set terminal postscript enhanced color";
    }
    else if (ext.compare("eps") == 0)
    {
      tmp_s << "set terminal postscript eps enhanced color";
    }
    else if (ext.compare("tex") == 0)
    {
      tmp_s << "set terminal cairolatex eps color enhanced";
    }
    else if (ext.compare("pdf") == 0)
    {
      tmp_s << "set terminal pdfcairo color enhanced";
    }
    else if (ext.compare("svg") == 0)
    {
      tmp_s << "set terminal svg enhanced";
    }
    else if (ext.compare("emf") == 0)
    {
      tmp_s << "set terminal emf color enhanced";
    }
    else if (ext.compare("gif") == 0)
    {
      tmp_s << "set terminal gif enhanced";
    }
    // else if (ext.compare("jpg") == 0)
    //{
    //  tmp_s << "set terminal jpeg ";
    //}
    else
    {
      tmp_s << "set terminal " << term;
    }
    std::string s = tmp_s.str();
    send2gp(s.c_str());
    tmp_s.str(""); // Clear buffer
    tmp_s << "set output '" << name_s << "'";
    s = tmp_s.str();
    send2gp(s.c_str());
  }

  void reset_term(void) { send2gp("reset session"); }

  void set_term(const char *ttype)
  {
    std::ostringstream tmp_s;
    tmp_s << "set terminal " << ttype;
    std::string s = tmp_s.str();
    term          = s;
    send2gp(s.c_str());
  }

}; // End Gnuplot Class


} // namespace sp
#endif