Compiler Explorer

Source code

#include<fmt/core.h>
#include <memory>
#include <ranges>
#include <vector>
#include <algorithm>
#include <experimental/random>
namespace ex = std::experimental;

// Point, color, and vertex are the proposed API between the plots and the backend
// probably need circles and something for text as well.
struct Point2f{
  float x = static_cast<float>(ex::randint(0,100));
  float y = static_cast<float>(ex::randint(0,100));
};
using Points = std::vector<Point2f>;

struct Color{
  //some definition of color
};

struct Vertex{
  Point2f position;
  Color color;
};
using VertexArray = std::vector<Vertex>;

// type erased backend container
class Backend {
 public:
  template <typename BackendT>
  Backend(BackendT backend)
    : pimpl{std::make_unique<BackendModel<BackendT>>(std::move(backend))} {}

// I think templating on the VertexArray type will make thing challenging. But 
  // I'm open to suggestions 
  void draw(const VertexArray& vertices) const { pimpl->do_draw(vertices); }
 private:
  struct BackendConcept {
    virtual ~BackendConcept() = default;
    virtual void do_draw(const VertexArray& vertices) const = 0;
  };

template <typename BackendT>
  struct BackendModel : public BackendConcept {
    BackendModel(BackendT backend) : backend_{std::move(backend)} {}
    void do_draw(const VertexArray& vertices) const override { backend_.draw(vertices); }

BackendT backend_;
  };

std::unique_ptr<BackendConcept> pimpl;
};

// type-erased plot container
class Plot {
   public:
    template <typename PlotT>
    Plot(PlotT plot)
        : pimpl{std::make_unique<PlotModel<PlotT>>(std::move(plot))} {}

VertexArray get_vertex_array() const { return pimpl->do_get_vertex_array(); }
  private:
    struct PlotConcept {
        virtual ~PlotConcept() = default;
        virtual VertexArray do_get_vertex_array() const = 0;
    };

template <typename PlotT>
    struct PlotModel : public PlotConcept {
        PlotModel(PlotT plot) : plot_{std::move(plot)} {}

VertexArray do_get_vertex_array() const override { return plot_.get_vertex_array(); }

PlotT plot_;
    };

std::unique_ptr<PlotConcept> pimpl;
};

// seems weird to have a subplot object hold a vector of plots. Maybe subfigure?
// It might be nice for each Subfigure to have a container of "Axes" objects for 
// instance in the case where some of the plots in the subfigure use the left axes and 
// some of the plots use the a right axes. Otherwise the plot object somehow has to know
// which axes a plot should go on
class Subfigure{
 public:

const std::vector<Plot>& plots() const {return plots_;}
  std::vector<Plot>& plots() {return plots_;}
 
 private:
  std::vector<Plot> plots_;
};
using Subfigures = std::vector<Subfigure>;

// main figure object
class Figure{
 public:
  template <class BackendType>
  Figure(BackendType &&be):backend_{std::move(be)} {}

Subfigures& subfigures() {return subfigures_;}
  const Subfigures& subfigures() const {return subfigures_;}

void draw() const {
    for(const auto& sf :subfigures_){
      for(const auto& plot : sf.plots()){
        backend_.draw(plot.get_vertex_array());
      }
    }
  }

private:
  Subfigures subfigures_;
  Backend backend_; // would need to figure out how to share backends between figures. probably some kind of singleton
};

// The specific backend.  Note it doesn't know it's a backend object, It's just a class
// that knows how do display a bunch of vertices on some window
class SFMLBackend{
 public:
 void draw(const VertexArray& vertices) const {
  fmt::print("drawing from sfml\n vertex array of size {} received\n", vertices.size());}
};

// Here's a plot object. It doesn't know anything about figures or subfigures,etc. It 
// doesn't even really know it's a plot. 
// Probably better to use std::ranges instead of iterators, I'm just not familiar with  
// how to use ranges. It's 100% possible there's a better way to do this. But 
// hopefully this illustrates the concept that a plottable class type should take some
// sort of input range type that can be transformed. 
template <class InputIterator, class Projection = std::identity>
class ScatterPlot{
 public:
  ScatterPlot(InputIterator begin, InputIterator end, Projection projection = {}): 
    begin_{begin}, end_{end}, projection_{projection} {}

// add lots of other functions to customize this plot type.

// this is what the backend calls. 
  VertexArray get_vertex_array() const{
    //first extract the point data from the type the user has given us. Like I say
    // I'm pretty sure we could use ranges here to take advantage of lazy evaluations and
    // make things nicer and more efficient.
    Points pts;
    std::transform(begin_, end_, std::back_inserter(pts), [this](const auto& p){
      return projection_(p);
    });
    // then do other magic here
    VertexArray va;
    std::transform(pts.begin(), pts.end(), std::back_inserter(va), [](const auto& p){
      return Vertex{p,{}};
    });
    return va;}
 private:
  InputIterator begin_;
  InputIterator end_;
  Projection projection_;
};

// my arbitrary type I want to plot
struct Particle{
  double x{};
  double y{};
  double z{};
};
using Particles = std::vector<Particle>;

int main(){

//my main figure
  Figure figure{SFMLBackend()};

// make up some random data. In this case the data is stored in a type the library
  // provides. 
  Points pts;
  std::generate_n(std::back_inserter(pts), 100, 
    [](){return Point2f{};});

ScatterPlot sp(pts.begin(), pts.end()); // we can chain additional methods here if we want
  // for setting options, etc.

figure.subfigures().emplace_back(Subfigure{}).plots().emplace_back(sp);

// make up some random data. This time we store it in our own object.
  Particles particles;
  std::generate_n(std::back_inserter(particles), 1000, 
    [](){return Particle{static_cast<double>(ex::randint(0,100)), static_cast<double>(ex::randint(0,100)), static_cast<double>(ex::randint(0,100))};});

// To plot it we provide a projection that converts an element of our type to an element
  // the library is familiar with. There might be a better way. 
  ScatterPlot sp2{particles.begin(), particles.end(), [](const auto& p){return Point2f(p.x, p.y);}};

figure.subfigures(/*1,3,1?*/).back().plots().emplace_back(sp2);

figure.draw();

}