Plot.h

Go to the documentation of this file.

#pragma once
 
#include "../Matrix.h"
#include "../matrix_utils.h"
#include "../numerics/utils.h"
#include <utility>
 
 
enum DataTypes {
  LINE = 1,
  DOTS = 2,
  NONE = -1,
};
 
const char* GetPlotDataTypeName(DataTypes type) {
  switch(type) {
    case LINE: return "lines ls 1";
    case DOTS: return "points ls 2"; // pointtype 5 pointsize 1.5";
    case NONE:
    default: return "none";
  }
}
 
struct PlotBoundary {
  double min;
  double max;
};
 
struct PlotIndex {
  int start = -1;
  int stop = -1;
};
 
struct PlotAttributes {
  char* title;
  char* xAxis;
  char* yAxis;
  int pointStrength;
  int lineStrength;
  bool is3D = false;
  bool is2D = false;
  unsigned int isStatPlot;
  const char* color;
  const char* colorPalette;
  std::vector<const char*> plotNames;
  std::vector<const char*> plotTypes;
  std::vector<const char*> characters;
  std::vector<PlotIndex> plotIndices;
};
 
class Plot
{
public:
  explicit Plot(const std::string& title = "") {
    dataFileName             = "line_plot_data.txt";
    plotTypeName             = "lines";
    attributes.pointStrength = 0;
    attributes.lineStrength  = 10;
    attributes.isStatPlot    = 0;
    attributes.color         = "#008080";
    attributes.title         = new char[title.size() + 1];
    std::copy(title.begin(), title.end(), attributes.title);
    attributes.title[title.size()] = '\0';
    clear_file();
  }
 
  void clear_file() {
    // create file and empty it
    storageFile = fopen(dataFileName, "w");
    fprintf(storageFile, "\0");
    fclose(storageFile);
  }
 
  void title(const std::string& title) {
    attributes.title = new char[title.size() + 1];
    std::copy(title.begin(), title.end(), attributes.title);
    attributes.title[title.size()] = '\0';
  }
 
  void xAxis(const std::string& name) {
    attributes.xAxis = new char[name.size() + 1];
    std::copy(name.begin(), name.end(), attributes.xAxis);
    attributes.xAxis[name.size()] = '\0';
  }
 
  void yAxis(const std::string& name) {
    attributes.yAxis = new char[name.size() + 1];
    std::copy(name.begin(), name.end(), attributes.yAxis);
    attributes.yAxis[name.size()] = '\0';
  }
 
  void pointSize(const int& size) { attributes.pointStrength = size; }
 
  void lineWidth(const int& size) { attributes.lineStrength = size; }
 
  void AddData(
  const Matrix<double>& x,
  const Matrix<double>& y,
  const std::string& name,
  DataTypes dataType    = DataTypes::NONE,
  const char* character = nullptr) {
    x.assertSize(y);
    AddData(HorizontalConcat(x, y), name, dataType, character);
  }
 
  void AddData(
  const Matrix<double>& mat,
  const std::string& name,
  DataTypes dataTypeName = DataTypes::NONE,
  const char* pointChar  = nullptr,
  int dimensions         = 2) {
    if(dimensions <= 3) {
      // calculate boundaries
      auto new_bX = getBoundaries(mat.GetSlice(0, mat.rows() - 1, 0, 0));
      auto new_bY = getBoundaries(mat.GetSlice(0, mat.rows() - 1, 1, 1));
 
      bX.min = bX.min > new_bX.min ? new_bX.min : bX.min;
      bX.max = bX.max < new_bX.max ? new_bX.max : bX.max;
 
      bY.min = bY.min > new_bY.min ? new_bY.min : bY.min;
      bY.max = bY.max < new_bY.max ? new_bY.max : bY.max;
    } else {
      bX.min = 0;
      bY.min = 0;
      bX.max = mat.columns();
      bY.max = mat.columns();
    }
 
    // append storage file
    storageFile = fopen(dataFileName, "a");
    if(storageFile == nullptr) {
      // error
      return;
    }
    fprintf(storageFile, "# ");
    fprintf(storageFile, "%s", dataFileName);
    fprintf(storageFile, "\n");
 
    for(size_t i = 0; i < mat.columns(); i += dimensions) {
      fprintf(storageFile, "# X Y Z\n");
      for(size_t j = 0; j < mat.rows(); ++j) {
        for(int k = 0; k < dimensions; ++k) { fprintf(storageFile, "%g ", mat(j, i + k)); }
        fprintf(storageFile, "\n");
      }
      fprintf(storageFile, "\n\n");
    }
    fclose(storageFile);
 
    char* newName;
    newName = new char[name.size() + 1];
    std::copy(name.begin(), name.end(), newName);
    newName[name.size()] = '\0';
    PlotIndex index      = { 0, -1 };
    if(!attributes.plotIndices.empty()) {
      index = attributes.plotIndices[attributes.plotIndices.size() - 1];
      index.start++;
    }
 
    attributes.plotIndices.push_back(index);
    attributes.plotNames.push_back(newName);
    attributes.plotTypes.push_back(dataTypeName == DataTypes::NONE ? plotTypeName : GetPlotDataTypeName(dataTypeName));
    attributes.characters.push_back(pointChar);
    numElements++;
  }
 
  virtual void operator()() const {
    FILE* gnuplot = popen("gnuplot --persist", "w");
    writeAttributes(gnuplot);
    for(int i = 0; i < numElements; ++i) {
      if(i == 0) { fprintf(gnuplot, "%s", plotType); }
      fprintf(gnuplot, "'%s'", dataFileName);
      auto index = attributes.plotIndices[i];
      if(index.stop != -1) {
        fprintf(gnuplot, " index %d:%d with ", index.start, index.stop);
      } else {
        fprintf(gnuplot, " index %d with ", index.start);
      }
      fprintf(gnuplot, "%s", attributes.plotTypes[i]);
      if(attributes.characters[i] != nullptr) { fprintf(gnuplot, "pt '%s'", attributes.characters[i]); }
      fprintf(gnuplot, " title '%s'", attributes.plotNames[i]);
      fprintf(gnuplot, i == (numElements - 1) ? "\n" : ",");
    }
    fprintf(gnuplot, "\n");
    fclose(gnuplot);
  }
 
private:
  [[nodiscard]] inline PlotBoundary getBoundaries(const Matrix<double>& x) const {
    /*
     * determines the boundaries of an array
     * returns: boundary(min, max)
     */
    double startX = min(x);
    //startX = startX - pow_(10, getExponent(startX) - 1);
    double endX = max(x);
    //endX = endX - pow_(10, getExponent(endX) - 1);
    PlotBoundary bond = { startX, endX };
    return bond;
  }
 
 
protected:
  const char* dataFileName;
  const char* plotTypeName;
  const char* plotType = "plot";
  FILE* storageFile = nullptr;
  PlotAttributes attributes = {};
  int numElements = 0;
  PlotBoundary bY{};
  PlotBoundary bX{};
 
  void writeAttributes(FILE* gnuplot) const {
    if(attributes.title) {
      char titleExtension[105];
      if(attributes.xAxis && attributes.yAxis && attributes.isStatPlot) {
        strcpy(titleExtension, attributes.xAxis);
        strcat(strcat(titleExtension, " vs. "), attributes.yAxis);
      }
      fprintf(gnuplot, "set title '%s", attributes.title);
      if(attributes.isStatPlot) { fprintf(gnuplot, "%s", titleExtension); }
      fprintf(gnuplot, "'\n");
    }
    fprintf(gnuplot, "set style line 1 lt 2 lc rgb \"red\" lw 3;\nset style line 1 lt 2 lc rgb \"orange\" lw 3;\n");
    if(attributes.xAxis) { fprintf(gnuplot, "set xlabel '%s'\n", attributes.xAxis); }
    if(attributes.yAxis) { fprintf(gnuplot, "set ylabel '%s'\n", attributes.yAxis); }
    if(attributes.is3D) { fprintf(gnuplot, "set hidden3d\nset dgrid3d 30,30 qnorm 1\n"); }
    if(attributes.colorPalette) { fprintf(gnuplot, "load '%s'\n", attributes.colorPalette); }
  }
};
 
class ScatterPlot : public Plot
{
public:
  explicit ScatterPlot(const char* name = "")
    : Plot(name) {
    dataFileName = "point_plot_data.txt";
    plotTypeName = "points";
    clear_file();
  }
};
 
class FunctionPlot : public Plot
{
  std::function<double(const double&)> Function;
 
public:
  explicit FunctionPlot(std::function<double(const double&)> fun, const char* name = "")
    : Plot(name)
    , Function(std::move(fun)) { }
 
  void AddData(const double& start, const double& end, const double& stepSize, const char* name) {
    int size         = (int)((end - start) / stepSize) + 2;
    Matrix<double> X = linspace(start, end, size);
    auto Y           = X.Apply(Function);
    Plot::AddData(X, Y, name);
  }
};
 
class SurfacePlot : public Plot
{
public:
  SurfacePlot(const std::string& title = "")
    : Plot(title) {
    plotType        = "splot";
    attributes.is3D = true;
  }
 
  void operator()() const override {
    FILE* gnuplot = popen("gnuplot --persist", "w");
    writeAttributes(gnuplot);
    fprintf(gnuplot, "%s", plotType);
    fprintf(gnuplot, " '%s' with lines", dataFileName);
    fprintf(gnuplot, " title '%s'", attributes.plotNames[0]);
    fprintf(gnuplot, "\n");
    fclose(gnuplot);
  }
};
 
class ImagePlot : public Plot
{
public:
  explicit ImagePlot(const char* name)
    : Plot(name) {
    attributes.is2D = true;
  }
 
  void AddData(const Matrix<double>& mat, const std::string& name) {
    Plot::AddData(mat, name, DataTypes::NONE, nullptr, mat.columns());
  }
 
  void operator()(const char* colorPalette = "magma.pal") {
    FILE* gnuplot           = popen("gnuplot --persist", "w");
    attributes.colorPalette = colorPalette;
    writeAttributes(gnuplot);
    fprintf(gnuplot, "plot '%s' matrix with image", dataFileName);
    fprintf(gnuplot, " title '%s'", attributes.plotNames[0]);
    fprintf(gnuplot, "\n");
    fclose(gnuplot);
  }
};