{

PyObject * s_python_function_arrow;

PyObject * s_python_function_show;

PyObject * s_python_function_close;

PyObject * s_python_function_draw;

PyObject * s_python_function_pause;

PyObject * s_python_function_save;

PyObject * s_python_function_figure;

PyObject * s_python_function_fignum_exists;

PyObject * s_python_function_plot;

PyObject * s_python_function_quiver;

PyObject * s_python_function_contour;

PyObject * s_python_function_semilogx;

PyObject * s_python_function_semilogy;

PyObject * s_python_function_loglog;

PyObject * s_python_function_fill;

PyObject * s_python_function_fill_between;

PyObject * s_python_function_hist;

PyObject * s_python_function_imshow;

PyObject * s_python_function_scatter;

PyObject * s_python_function_boxplot;

PyObject * s_python_function_subplot;

PyObject * s_python_function_subplot2grid;

PyObject * s_python_function_legend;

PyObject * s_python_function_xlim;

PyObject * s_python_function_ion;

PyObject * s_python_function_ginput;

PyObject * s_python_function_ylim;

PyObject * s_python_function_title;

PyObject * s_python_function_axis;

PyObject * s_python_function_axvline;

PyObject * s_python_function_axvspan;

PyObject * s_python_function_xlabel;

PyObject * s_python_function_ylabel;

PyObject * s_python_function_gca;

PyObject * s_python_function_xticks;

PyObject * s_python_function_yticks;

PyObject * s_python_function_margins;

PyObject * s_python_function_tick_params;

PyObject * s_python_function_grid;

PyObject * s_python_function_cla;

PyObject * s_python_function_clf;

PyObject * s_python_function_errorbar;

PyObject * s_python_function_annotate;

PyObject * s_python_function_tight_layout;

PyObject * s_python_colormap;

PyObject * s_python_empty_tuple;

PyObject * s_python_function_stem;

PyObject * s_python_function_xkcd;

PyObject * s_python_function_text;

PyObject * s_python_function_suptitle;

PyObject * s_python_function_bar;

PyObject * s_python_function_barh;

PyObject * s_python_function_colorbar;

PyObject * s_python_function_subplots_adjust;

/* For now, _interpreter is implemented as a singleton since its

static _interpreter & get()

{

return interkeeper(false);

}

static _interpreter & kill()

{

return interkeeper(true);

}

// Stores the actual singleton object referenced by `get()` and

// `kill()`.

static _interpreter & interkeeper(bool should_kill)

{

static _interpreter ctx;

if (should_kill)

ctx.~_interpreter();

return ctx;

}

PyObject * safe_import(PyObject * module, std::string fname)

{

PyObject * fn = PyObject_GetAttrString(module, fname.c_str());

if (!fn)

throw std::runtime_error(

std::string("Couldn't find required function: ") + fname);

if (!PyFunction_Check(fn))

throw std::runtime_error(

fname + std::string(" is unexpectedly not a PyFunction."));

return fn;

}

private:

#ifndef WITHOUT_NUMPY

#if PY_MAJOR_VERSION >= 3

void * import_numpy()

{

import_array(); // initialize C-API

return NULL;

}

#else

void import_numpy()

{

import_array(); // initialize C-API

}

#endif

#endif

_interpreter()

{

// optional but recommended

#if PY_MAJOR_VERSION >= 3

wchar_t name[] = L"plotting";

#else

char name[] = "plotting";

#endif

Py_SetProgramName(name);

Py_Initialize();

wchar_t const * dummy_args[] = {L"Python", NULL}; // const is needed

// because

// literals must

// not be modified

wchar_t const ** argv = dummy_args;

int argc = sizeof(dummy_args) / sizeof(dummy_args[0]) - 1;

PySys_SetArgv(argc, const_cast<wchar_t **>(argv));

#ifndef WITHOUT_NUMPY

import_numpy(); // initialize numpy C-API

#endif

PyObject * matplotlibname = PyString_FromString("matplotlib");

PyObject * pyplotname = PyString_FromString("matplotlib.pyplot");

PyObject * cmname = PyString_FromString("matplotlib.cm");

PyObject * pylabname = PyString_FromString("pylab");

if (!pyplotname || !pylabname || !matplotlibname || !cmname)

{

throw std::runtime_error("couldnt create string");

}

PyObject * matplotlib = PyImport_Import(matplotlibname);

Py_DECREF(matplotlibname);

if (!matplotlib)

{

PyErr_Print();

throw std::runtime_error("Error loading module matplotlib!");

}

// matplotlib.use() must be called *before* pylab,

// matplotlib.pyplot, or matplotlib.backends is imported for the

// first time

if (!s_backend.empty())

{

PyObject_CallMethod(matplotlib,

const_cast<char *>("use"),

const_cast<char *>("s"),

s_backend.c_str());

}

PyObject * pymod = PyImport_Import(pyplotname);

Py_DECREF(pyplotname);

if (!pymod)

{

throw std::runtime_error(

"Error loading module matplotlib.pyplot!");

}

s_python_colormap = PyImport_Import(cmname);

Py_DECREF(cmname);

if (!s_python_colormap)

{

throw std::runtime_error("Error loading module matplotlib.cm!");

}

PyObject * pylabmod = PyImport_Import(pylabname);

Py_DECREF(pylabname);

if (!pylabmod)

{

throw std::runtime_error("Error loading module pylab!");

}

s_python_function_arrow = safe_import(pymod, "arrow");

s_python_function_show = safe_import(pymod, "show");

s_python_function_close = safe_import(pymod, "close");

s_python_function_draw = safe_import(pymod, "draw");

s_python_function_pause = safe_import(pymod, "pause");

s_python_function_figure = safe_import(pymod, "figure");

s_python_function_fignum_exists =

safe_import(pymod, "fignum_exists");

s_python_function_plot = safe_import(pymod, "plot");

s_python_function_quiver = safe_import(pymod, "quiver");

s_python_function_contour = safe_import(pymod, "contour");

s_python_function_semilogx = safe_import(pymod, "semilogx");

s_python_function_semilogy = safe_import(pymod, "semilogy");

s_python_function_loglog = safe_import(pymod, "loglog");

s_python_function_fill = safe_import(pymod, "fill");

s_python_function_fill_between = safe_import(pymod, "fill_between");

s_python_function_hist = safe_import(pymod, "hist");

s_python_function_scatter = safe_import(pymod, "scatter");

s_python_function_boxplot = safe_import(pymod, "boxplot");

s_python_function_subplot = safe_import(pymod, "subplot");

s_python_function_subplot2grid = safe_import(pymod, "subplot2grid");

s_python_function_legend = safe_import(pymod, "legend");

s_python_function_ylim = safe_import(pymod, "ylim");

s_python_function_title = safe_import(pymod, "title");

s_python_function_axis = safe_import(pymod, "axis");

s_python_function_axvline = safe_import(pymod, "axvline");

s_python_function_axvspan = safe_import(pymod, "axvspan");

s_python_function_xlabel = safe_import(pymod, "xlabel");

s_python_function_ylabel = safe_import(pymod, "ylabel");

s_python_function_gca = safe_import(pymod, "gca");

s_python_function_xticks = safe_import(pymod, "xticks");

s_python_function_yticks = safe_import(pymod, "yticks");

s_python_function_margins = safe_import(pymod, "margins");

s_python_function_tick_params = safe_import(pymod, "tick_params");

s_python_function_grid = safe_import(pymod, "grid");

s_python_function_xlim = safe_import(pymod, "xlim");

s_python_function_ion = safe_import(pymod, "ion");

s_python_function_ginput = safe_import(pymod, "ginput");

s_python_function_save = safe_import(pylabmod, "savefig");

s_python_function_annotate = safe_import(pymod, "annotate");

s_python_function_cla = safe_import(pymod, "cla");

s_python_function_clf = safe_import(pymod, "clf");

s_python_function_errorbar = safe_import(pymod, "errorbar");

s_python_function_tight_layout = safe_import(pymod, "tight_layout");

s_python_function_stem = safe_import(pymod, "stem");

s_python_function_xkcd = safe_import(pymod, "xkcd");

s_python_function_text = safe_import(pymod, "text");

s_python_function_suptitle = safe_import(pymod, "suptitle");

s_python_function_bar = safe_import(pymod, "bar");

s_python_function_barh = safe_import(pymod, "barh");

s_python_function_colorbar =

PyObject_GetAttrString(pymod, "colorbar");

s_python_function_subplots_adjust =

safe_import(pymod, "subplots_adjust");

#ifndef WITHOUT_NUMPY

s_python_function_imshow = safe_import(pymod, "imshow");

#endif

s_python_empty_tuple = PyTuple_New(0);

}

~_interpreter()

{

Py_Finalize();

}

{

detail::_interpreter::get();

PyObject * xy = PyTuple_New(2);

PyObject * str = PyString_FromString(annotation.c_str());

PyTuple_SetItem(xy, 0, PyFloat_FromDouble(x));

PyTuple_SetItem(xy, 1, PyFloat_FromDouble(y));

PyObject * kwargs = PyDict_New();

PyDict_SetItemString(kwargs, "xy", xy);

PyObject * args = PyTuple_New(1);

PyTuple_SetItem(args, 0, str);

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_annotate, args, kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

const std::vector<Numeric> & y,

const std::map<std::string, std::string> & keywords)

{

assert(x.size() == y.size());

detail::_interpreter::get();

// using numpy arrays

PyObject * xarray = detail::get_array(x);

PyObject * yarray = detail::get_array(y);

// construct positional args

PyObject * args = PyTuple_New(2);

PyTuple_SetItem(args, 0, xarray);

PyTuple_SetItem(args, 1, yarray);

// construct keyword args

PyObject * kwargs = PyDict_New();

for (std::map<std::string, std::string>::const_iterator it =

keywords.begin();

it != keywords.end();

++it)

{

PyDict_SetItemString(

kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));

}

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_plot, args, kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

const std::vector<::std::vector<Numeric>> & y,

const std::vector<::std::vector<Numeric>> & z,

const std::map<std::string, std::string> & keywords =

std::map<std::string, std::string>())

{

detail::_interpreter::get();

// We lazily load the modules here the first time this function is called

// because I'm not sure that we can assume "matplotlib installed" implies

// "mpl_toolkits installed" on all platforms, and we don't want to require

// it for people who don't need 3d plots.

static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;

if (!mpl_toolkitsmod)

{

detail::_interpreter::get();

PyObject * mpl_toolkits = PyString_FromString("mpl_toolkits");

PyObject * axis3d = PyString_FromString("mpl_toolkits.mplot3d");

if (!mpl_toolkits || !axis3d)

{

throw std::runtime_error("couldnt create string");

}

mpl_toolkitsmod = PyImport_Import(mpl_toolkits);

Py_DECREF(mpl_toolkits);

if (!mpl_toolkitsmod)

{

throw std::runtime_error("Error loading module mpl_toolkits!");

}

axis3dmod = PyImport_Import(axis3d);

Py_DECREF(axis3d);

if (!axis3dmod)

{

throw std::runtime_error(

"Error loading module mpl_toolkits.mplot3d!");

}

}

assert(x.size() == y.size());

assert(y.size() == z.size());

// using numpy arrays

PyObject * xarray = detail::get_2darray(x);

PyObject * yarray = detail::get_2darray(y);

PyObject * zarray = detail::get_2darray(z);

// construct positional args

PyObject * args = PyTuple_New(3);

PyTuple_SetItem(args, 0, xarray);

PyTuple_SetItem(args, 1, yarray);

PyTuple_SetItem(args, 2, zarray);

// Build up the kw args.

PyObject * kwargs = PyDict_New();

PyDict_SetItemString(kwargs, "rstride", PyInt_FromLong(1));

PyDict_SetItemString(kwargs, "cstride", PyInt_FromLong(1));

PyObject * python_colormap_coolwarm = PyObject_GetAttrString(

detail::_interpreter::get().s_python_colormap, "coolwarm");

PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);

for (std::map<std::string, std::string>::const_iterator it =

keywords.begin();

it != keywords.end();

++it)

{

PyDict_SetItemString(

kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));

}

PyObject * fig = PyObject_CallObject(

detail::_interpreter::get().s_python_function_figure,

detail::_interpreter::get().s_python_empty_tuple);

if (!fig)

throw std::runtime_error("Call to figure() failed.");

PyObject * gca_kwargs = PyDict_New();

PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));

PyObject * gca = PyObject_GetAttrString(fig, "gca");

if (!gca)

throw std::runtime_error("No gca");

Py_INCREF(gca);

PyObject * axis = PyObject_Call(

gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);

if (!axis)

throw std::runtime_error("No axis");

Py_INCREF(axis);

Py_DECREF(gca);

Py_DECREF(gca_kwargs);

PyObject * plot_surface = PyObject_GetAttrString(axis, "plot_surface");

if (!plot_surface)

throw std::runtime_error("No surface");

Py_INCREF(plot_surface);

PyObject * res = PyObject_Call(plot_surface, args, kwargs);

if (!res)

throw std::runtime_error("failed surface");

Py_DECREF(plot_surface);

Py_DECREF(axis);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

const std::vector<Numeric> & y,

const std::vector<Numeric> & z,

const std::map<std::string, std::string> & keywords =

std::map<std::string, std::string>())

{

detail::_interpreter::get();

// Same as with plot_surface: We lazily load the modules here the first time

// this function is called because I'm not sure that we can assume

// "matplotlib installed" implies "mpl_toolkits installed" on all platforms,

// and we don't want to require it for people who don't need 3d plots.

static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;

if (!mpl_toolkitsmod)

{

detail::_interpreter::get();

PyObject * mpl_toolkits = PyString_FromString("mpl_toolkits");

PyObject * axis3d = PyString_FromString("mpl_toolkits.mplot3d");

if (!mpl_toolkits || !axis3d)

{

throw std::runtime_error("couldnt create string");

}

mpl_toolkitsmod = PyImport_Import(mpl_toolkits);

Py_DECREF(mpl_toolkits);

if (!mpl_toolkitsmod)

{

throw std::runtime_error("Error loading module mpl_toolkits!");

}

axis3dmod = PyImport_Import(axis3d);

Py_DECREF(axis3d);

if (!axis3dmod)

{

throw std::runtime_error(

"Error loading module mpl_toolkits.mplot3d!");

}

}

static PyObject * axis = nullptr;

if (axis == nullptr)

{

PyObject * fig = PyObject_CallObject(

matplotlibcpp::detail::_interpreter::get().s_python_function_figure,

matplotlibcpp::detail::_interpreter::get().s_python_empty_tuple);

PyObject * gca_kwargs = PyDict_New();

PyDict_SetItemString(

gca_kwargs, "projection", PyString_FromString("3d"));

PyObject * gca = PyObject_GetAttrString(fig, "gca");

if (!gca)

throw std::runtime_error("No gca");

Py_INCREF(gca);

axis = PyObject_Call(

gca,

matplotlibcpp::detail::_interpreter::get().s_python_empty_tuple,

gca_kwargs);

}

assert(x.size() == y.size());

assert(y.size() == z.size());

PyObject * xarray = detail::get_array(x);

PyObject * yarray = detail::get_array(y);

PyObject * zarray = detail::get_array(z);

// construct positional args

PyObject * args = PyTuple_New(3);

PyTuple_SetItem(args, 0, xarray);

PyTuple_SetItem(args, 1, yarray);

PyTuple_SetItem(args, 2, zarray);

// Build up the kw args.

PyObject * kwargs = PyDict_New();

for (std::map<std::string, std::string>::const_iterator it =

keywords.begin();

it != keywords.end();

++it)

{

PyDict_SetItemString(

kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));

}

if (!axis)

throw std::runtime_error("No axis");

Py_INCREF(axis);

// Py_DECREF(gca);

// Py_DECREF(gca_kwargs);

PyObject * plot3 = PyObject_GetAttrString(axis, "plot");

if (!plot3)

throw std::runtime_error("No 3D line plot");

Py_INCREF(plot3);

PyObject * res = PyObject_Call(plot3, args, kwargs);

if (!res)

throw std::runtime_error("Failed 3D line plot");

Py_DECREF(plot3);

Py_DECREF(axis);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

const std::vector<Numeric> & y,

const std::map<std::string, std::string> & keywords)

{

assert(x.size() == y.size());

detail::_interpreter::get();

// using numpy arrays

PyObject * xarray = detail::get_array(x);

PyObject * yarray = detail::get_array(y);

// construct positional args

PyObject * args = PyTuple_New(2);

PyTuple_SetItem(args, 0, xarray);

PyTuple_SetItem(args, 1, yarray);

// construct keyword args

PyObject * kwargs = PyDict_New();

for (std::map<std::string, std::string>::const_iterator it =

keywords.begin();

it != keywords.end();

++it)

{

PyDict_SetItemString(

kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));

}

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_stem, args, kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

const std::vector<Numeric> & y,

const std::map<std::string, std::string> & keywords)

{

assert(x.size() == y.size());

detail::_interpreter::get();

// using numpy arrays

PyObject * xarray = detail::get_array(x);

PyObject * yarray = detail::get_array(y);

// construct positional args

PyObject * args = PyTuple_New(2);

PyTuple_SetItem(args, 0, xarray);

PyTuple_SetItem(args, 1, yarray);

// construct keyword args

PyObject * kwargs = PyDict_New();

for (auto it = keywords.begin(); it != keywords.end(); ++it)

{

PyDict_SetItemString(kwargs,

it->first.c_str(),

PyUnicode_FromString(it->second.c_str()));

}

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_fill, args, kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

const std::vector<Numeric> & y1,

const std::vector<Numeric> & y2,

const std::map<std::string, std::string> & keywords)

{

assert(x.size() == y1.size());

assert(x.size() == y2.size());

detail::_interpreter::get();

// using numpy arrays

PyObject * xarray = detail::get_array(x);

PyObject * y1array = detail::get_array(y1);

PyObject * y2array = detail::get_array(y2);

// construct positional args

PyObject * args = PyTuple_New(3);

PyTuple_SetItem(args, 0, xarray);

PyTuple_SetItem(args, 1, y1array);

PyTuple_SetItem(args, 2, y2array);

// construct keyword args

PyObject * kwargs = PyDict_New();

for (std::map<std::string, std::string>::const_iterator it =

keywords.begin();

it != keywords.end();

++it)

{

PyDict_SetItemString(kwargs,

it->first.c_str(),

PyUnicode_FromString(it->second.c_str()));

}

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_fill_between,

args,

kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

Numeric y,

Numeric end_x,

Numeric end_y,

const std::string & fc = "r",

const std::string ec = "k",

Numeric head_length = 0.25,

Numeric head_width = 0.1625)

{

PyObject * obj_x = PyFloat_FromDouble(x);

PyObject * obj_y = PyFloat_FromDouble(y);

PyObject * obj_end_x = PyFloat_FromDouble(end_x);

PyObject * obj_end_y = PyFloat_FromDouble(end_y);

PyObject * kwargs = PyDict_New();

PyDict_SetItemString(kwargs, "fc", PyString_FromString(fc.c_str()));

PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));

PyDict_SetItemString(kwargs, "head_width", PyFloat_FromDouble(head_width));

PyDict_SetItemString(

kwargs, "head_length", PyFloat_FromDouble(head_length));

PyObject * plot_args = PyTuple_New(4);

PyTuple_SetItem(plot_args, 0, obj_x);

PyTuple_SetItem(plot_args, 1, obj_y);

PyTuple_SetItem(plot_args, 2, obj_end_x);

PyTuple_SetItem(plot_args, 3, obj_end_y);

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_arrow, plot_args, kwargs);

Py_DECREF(plot_args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

long bins = 10,

std::string color = "b",

double alpha = 1.0,

bool cumulative = false)

{

detail::_interpreter::get();

PyObject * yarray = detail::get_array(y);

PyObject * kwargs = PyDict_New();

PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));

PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));

PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));

PyDict_SetItemString(kwargs, "cumulative", cumulative ? Py_True : Py_False);

PyObject * plot_args = PyTuple_New(1);

PyTuple_SetItem(plot_args, 0, yarray);

PyObject * res = PyObject_Call(

detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);

Py_DECREF(plot_args);

Py_DECREF(kwargs);

if (res)

Py_DECREF(res);

return res;

const NPY_TYPES type,

const int rows,

const int columns,

const int colors,

const std::map<std::string, std::string> & keywords,

PyObject ** out)

{

assert(type == NPY_UINT8 || type == NPY_FLOAT);

assert(colors == 1 || colors == 3 || colors == 4);

detail::_interpreter::get();