---

tnt_gnuplot.h

Go to the documentation of this file.

#ifndef __GNUPLOT_H__
#define __GNUPLOT_H__

#include <iostream>
#include <fstream>
#include <cstdio>
#include <string>
using std::string;
#include <vector>
#include "matrix.h"

#include "ind_types.h"



namespace vec {


/*
  Most of the types used are generic to keep the routines as general
  as possible, but the shortcut routines which generate their own axis
  labels use these definitions to construct them.
*/
typedef double                 AxisCoord;
typedef std::vector<AxisCoord> AxisVector;
typedef AxisVector::size_type  AxisSubscript;


 
/******************************************************************************/
/* Private routines                                                           */
/******************************************************************************/


/* If you have a tempnam() function on your system, do a
   #define TEMPNAME tempnam
   Otherwise write such function or edit this one. 
*/
inline string temporaryname(const string prefix)
{
  char* matrixfilechars = TEMPNAME(0,prefix.c_str());
  string matrixfilename(matrixfilechars);
  free(matrixfilechars);
  return matrixfilename;
}

 

inline string call_gnuplot(const string& title,
                           const string& matrixfilename,
                           const string& outputfilename,
                           const string& gpscript_command,
                           bool parametric)
{
  const bool   interactive=(outputfilename=="");
  const bool   view_as_ps=true; // Leaves outputfile in tmp, though
  const bool   create_ps=(!interactive || view_as_ps);
  const string ps_view_command="ghostview";

  const string gpscript_save_to_ps =
    "set terminal postscript eps color solid 'Times-Roman' 14\n"
    "set output '";

  const string gpscript_display = "pause -1\n";

  const string scriptfilename = temporaryname("gnupl");

  const string outfilename = (outputfilename!="" ? outputfilename :
                              temporaryname("gnupl"));
    
  /* Create scriptfile */
  {
    std::ofstream scriptfile(scriptfilename.c_str());
    if (!scriptfile) return "Cannot open temporary script file";
    
    // write script to temporary file  
    if (create_ps)  scriptfile << gpscript_save_to_ps << outfilename << "'\n";
    if (parametric) scriptfile << "set parametric\n";
    
    scriptfile << "set title '" << title << "'\n";
    
    unsigned pos;
    string p = gpscript_command;
    const string filenamemarker="Matrix";
    while ((pos=p.find(filenamemarker))<p.length())
      p.replace(pos,filenamemarker.length(),matrixfilename);
    
    scriptfile << p;
    if (!create_ps) scriptfile << gpscript_display;
    
    if (scriptfile.bad()) return "Error writing script file";
  }
  
  // call gnuplot
  string cmd = "gnuplot " + scriptfilename;
  system(cmd.c_str());

  // remove temporary files
  if (remove(scriptfilename.c_str()) || remove(matrixfilename.c_str()))
    return "Cannot remove temporary files";

  if (interactive && view_as_ps) {
    string viewcmd = ps_view_command + " " + outfilename + "&";
    system(viewcmd.c_str());
  }
  
  return "";
}




/******************************************************************************/
/* 1D vector plots                                                            */
/******************************************************************************/


template <class VectorA, class VectorX>
string gnuplot(const VectorA& A,
                    const string&  title,
                    const string&  outputfilename,
                    const string&  gpscript,
                    const VectorX& X)
{
  typedef typename VectorA::size_type  Subscript;
  
  if (Subscript(X.size())!=Subscript(A.size()))
                    return "Skipping; axis vector incompatible with vector size";
  if (!A.size())    return "Skipping empty vector";
  if (A.size()==1)  return "Skipping single-element vector";

  /* Create matrix file */
  {
    string matrixfilename = temporaryname("gnupl");
    std::ofstream matrixfile(matrixfilename.c_str());
    if (!matrixfile) return "Cannot open temporary file";
    
    // write matrix to temporary file
    for (Subscript i=0; i<A.size(); i++) {
      matrixfile << X[i] << " ";
      matrixfile << A[i] << " ";
      matrixfile << std::endl;
    }
    
    if (matrixfile.bad()) return "Error writing matrix file";
  }
  
  return call_gnuplot
    ( title,matrixfilename,outputfilename,

        gpscript!="" ? gpscript :
        "set xlabel 'Element'\n"
        "set ylabel 'Value'\n"
        "plot 'Matrix' notitle with lines\n",
        
        false);
}



template <class Vector>
string gnuplot(const Vector& A,
                    const string& title="",
                    const string& outputfilename="",
                    const string& gpscript="",
                    AxisCoord xo=0, AxisCoord xm=1)
{
  AxisVector X(A.size(),0.0);
  for (AxisSubscript i=0; i<AxisSubscript(A.size()); i++) X[i]=xo+i*xm;
  return gnuplot(A,title,outputfilename,gpscript,X);
}


} /* namespace vec */



/******************************************************************************/
/* 2D matrix plots                                                            */
/******************************************************************************/

namespace mat {
  using vec::call_gnuplot;
  using vec::temporaryname;
  using vec::AxisCoord;
  using vec::AxisVector;
  using vec::AxisSubscript;

 
template <class Matrix, class Vector>
string gnuplot(const Matrix& A,
               const string& title,
               const string& outputfilename,
               const string& gpscript,
               const Vector& R,
               const Vector& C)
{
  typedef typename Matrix::size_type  Subscript;
  
  if (int(C.size())!=int(A.ncols())) return "Skipping; column axis vector incompatible with matrix size";
  if (int(R.size())!=int(A.nrows())) return "Skipping; row axis vector incompatible with matrix size";
  if (A.ncols()==0 || A.nrows()==0)  return "Skipping empty matrix";
  if (A.ncols()==1 && A.nrows()==1)  return "Skipping single-element matrix";

  const string matrixfilename = temporaryname("gnupl");
  
  /* Create matrix file */
  {
    std::ofstream matrixfile(matrixfilename.c_str());
    if (!matrixfile) return "Cannot open temporary file";
    
    // write matrix to temporary file
    for (Subscript i=0; i<A.nrows(); i++) {
      for (Subscript j=0; j<A.ncols(); j++) {
        matrixfile << R[i] << " ";
        matrixfile << C[j] << " ";
        matrixfile << mat::elem(A,i,j) << std::endl;
      }
      matrixfile << std::endl;
    }
    
    if (matrixfile.bad()) return "Error writing matrix file";
  }
  
  return call_gnuplot
    ( title,matrixfilename,outputfilename,

      gpscript != "" ? gpscript :
      "set xlabel 'R'\n"
      "set ylabel 'C'\n"
      "set zlabel 'Value'\n"
      "set hidden3d\n"
      "splot 'Matrix' notitle with lines\n",
      
      true);
}



template <class Matrix>
string gnuplot(const Matrix& A,
                    const string& title="",
                    const string& outputfilename="",
                    const string& gpscript="",
                    AxisCoord Ro=0, AxisCoord Rm=1,
                    AxisCoord Co=0, AxisCoord Cm=1)
{
  AxisVector R(A.nrows(),0.0);
  for (AxisSubscript i=0; i<AxisSubscript(A.nrows()); i++) R[i]=Ro+i*Rm;

  AxisVector C(A.ncols(),0.0);
  for (AxisSubscript j=0; j<AxisSubscript(A.ncols()); j++) C[j]=Co+j*Cm;
  
  return gnuplot(A,title,outputfilename,gpscript,R,C);
}



} /* namespace mat */


#endif

---