#pragma once

// Python headers must be included before any system headers, since

// they define _POSIX_C_SOURCE

// Qt defines 'slots' as a macro, which clashes with a struct member in Python.h; temporarily undefine it.

#pragma push_macro("slots")

#undef slots

#include <Python.h>

#pragma pop_macro("slots")

#include <vector>

#include <map>

#include <array>

#include <numeric>

#include <algorithm>

#include <stdexcept>

#include <iostream>

#include <cstdint> // <cstdint> requires c++11 support

#include <functional>

#include <string> // std::stod

#ifndef WITHOUT_NUMPY

# define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION

# include <numpy/arrayobject.h>

# ifdef WITH_OPENCV

# include <opencv2/opencv.hpp>

/*

* A bunch of constants were removed in OpenCV 4 in favour of enum classes, so

* define the ones we need here.

*/

# if CV_MAJOR_VERSION > 3

# define CV_BGR2RGB cv::COLOR_BGR2RGB

# define CV_BGRA2RGBA cv::COLOR_BGRA2RGBA

# endif

# endif // WITH_OPENCV

#endif // WITHOUT_NUMPY

#if PY_MAJOR_VERSION >= 3

# define PyString_FromString PyUnicode_FromString

# define PyInt_FromLong PyLong_FromLong

# define PyString_FromString PyUnicode_FromString

#endif

namespace matplotlibcpp {

namespace detail {

static std::string s_backend;

struct _interpreter {

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_gcf;

PyObject *s_python_function_plot;

PyObject *s_python_function_quiver;

PyObject* s_python_function_contour;

PyObject* s_python_function_contourf;

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_ioff;

PyObject *s_python_function_ginput;

PyObject *s_python_function_ylim;

PyObject *s_python_function_title;

PyObject *s_python_function_axis;

PyObject *s_python_function_axhline;

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;

PyObject *s_python_function_rcparams;

PyObject *s_python_function_spy;

/* For now, _interpreter is implemented as a singleton since its currently not possible to have

multiple independent embedded python interpreters without patching the python source code

or starting a separate process for each. [1]

Furthermore, many python objects expect that they are destructed in the same thread as they

were constructed. [2] So for advanced usage, a `kill()` function is provided so that library

users can manually ensure that the interpreter is constructed and destroyed within the

same thread.

1: http://bytes.com/topic/python/answers/793370-multiple-independent-python-interpreters-c-c-program

2: https://github.com/lava/matplotlib-cpp/pull/202#issue-436220256

*/

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

static wchar_t name[] = L"plotting";

#else

static char name[] = "plotting";

#endif

#if PY_VERSION_HEX < 0x030B0000

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;

#if PY_MAJOR_VERSION >= 3

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

#else

PySys_SetArgv(argc, (char **)(argv));

#endif

#else

PyStatus status;

PyConfig config;

PyConfig_InitPythonConfig(&config);

wchar_t const* dummy_args[] = { L"Python", NULL }; // const is needed because literals must not be modified

wchar_t* const* argv = const_cast<wchar_t* const*>(dummy_args);

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

status = PyConfig_SetString(&config, &config.program_name, name);

if (PyStatus_Exception(status)) {

PyConfig_Clear(&config);

throw std::runtime_error("Failed to initialize Python interpreter");

}

status = PyConfig_SetArgv(&config, argc, argv);

if (PyStatus_Exception(status)) {

PyConfig_Clear(&config);

throw std::runtime_error("Failed to initialize Python interpreter");

}

status = Py_InitializeFromConfig(&config);

if (PyStatus_Exception(status)) {

PyConfig_Clear(&config);

throw std::runtime_error("Failed to initialize Python interpreter");

}

PyConfig_Clear(&config);

#endif

#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) {

PyErr_Print();

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

}

s_python_colormap = PyImport_Import(cmname);

Py_DECREF(cmname);

if (!s_python_colormap) {

PyErr_Print();

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

}

PyObject* pylabmod = PyImport_Import(pylabname);

Py_DECREF(pylabname);

if (!pylabmod) {

PyErr_Print();

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_gcf = safe_import(pymod, "gcf");

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_contourf = safe_import(pymod, "contourf");

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_xlim = safe_import(pymod, "xlim");

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_axhline = safe_import(pymod, "axhline");

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_ion = safe_import(pymod, "ion");

s_python_function_ioff = safe_import(pymod, "ioff");

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");

s_python_function_rcparams = PyObject_GetAttrString(pymod, "rcParams");

s_python_function_spy = PyObject_GetAttrString(pymod, "spy");

#ifndef WITHOUT_NUMPY

s_python_function_imshow = safe_import(pymod, "imshow");

#endif

s_python_empty_tuple = PyTuple_New(0);

}

~_interpreter() {

Py_Finalize();

}

};

} // end namespace detail

/// Select the backend

///

/// **NOTE:** This must be called before the first plot command to have

/// any effect.

///

/// Mainly useful to select the non-interactive 'Agg' backend when running

/// matplotlibcpp in headless mode, for example on a machine with no display.

///

/// See also: https://matplotlib.org/2.0.2/api/matplotlib_configuration_api.html#matplotlib.use

inline void backend(const std::string& name)

{

detail::s_backend = name;

}

inline bool annotate(std::string annotation, double x, double y)

{

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 bool(res);

}

namespace detail {

#ifndef WITHOUT_NUMPY

// Type selector for numpy array conversion.

// Specialize on the distinct fundamental types, not on the fixed-width typedefs:

// int64_t is `long` on some platforms and `long long` on others, so specializing

// on both would be a redefinition there. numpy's C-type enums match the C types

// on every platform, and int8_t...uint64_t resolve to one of these automatically.

template <typename T> struct select_npy_type { const static NPY_TYPES type = NPY_NOTYPE; }; //Default

template <> struct select_npy_type<double> { const static NPY_TYPES type = NPY_DOUBLE; };

template <> struct select_npy_type<float> { const static NPY_TYPES type = NPY_FLOAT; };

template <> struct select_npy_type<bool> { const static NPY_TYPES type = NPY_BOOL; };

template <> struct select_npy_type<signed char> { const static NPY_TYPES type = NPY_BYTE; };

template <> struct select_npy_type<short> { const static NPY_TYPES type = NPY_SHORT; };

template <> struct select_npy_type<int> { const static NPY_TYPES type = NPY_INT; };

template <> struct select_npy_type<long> { const static NPY_TYPES type = NPY_LONG; };

template <> struct select_npy_type<long long> { const static NPY_TYPES type = NPY_LONGLONG; };

template <> struct select_npy_type<unsigned char> { const static NPY_TYPES type = NPY_UBYTE; };

template <> struct select_npy_type<unsigned short> { const static NPY_TYPES type = NPY_USHORT; };

template <> struct select_npy_type<unsigned int> { const static NPY_TYPES type = NPY_UINT; };

template <> struct select_npy_type<unsigned long> { const static NPY_TYPES type = NPY_ULONG; };

template <> struct select_npy_type<unsigned long long> { const static NPY_TYPES type = NPY_ULONGLONG; };

template<typename Numeric>

PyObject* get_array(const std::vector<Numeric>& v)

{

npy_intp vsize = static_cast<npy_intp>(v.size());

NPY_TYPES type = select_npy_type<Numeric>::type;

if (type == NPY_NOTYPE) {

size_t memsize = v.size()*sizeof(double);

double* dp = static_cast<double*>(::malloc(memsize));

for (size_t i=0; i<v.size(); ++i)

dp[i] = v[i];

PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, NPY_DOUBLE, dp);

PyArray_UpdateFlags(reinterpret_cast<PyArrayObject*>(varray), NPY_ARRAY_OWNDATA);

return varray;

}

PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, type, (void*)(v.data()));

return varray;

}

template<typename Numeric>

PyObject* get_2darray(const std::vector<::std::vector<Numeric>>& v)

{

if (v.size() < 1) throw std::runtime_error("get_2d_array v too small");

npy_intp vsize[2] = {static_cast<npy_intp>(v.size()),

static_cast<npy_intp>(v[0].size())};

PyArrayObject *varray =

(PyArrayObject *)PyArray_SimpleNew(2, vsize, NPY_DOUBLE);

double *vd_begin = static_cast<double *>(PyArray_DATA(varray));

for (const ::std::vector<Numeric> &v_row : v) {

if (v_row.size() != static_cast<size_t>(vsize[1]))

throw std::runtime_error("Missmatched array size");

std::copy(v_row.begin(), v_row.end(), vd_begin);

vd_begin += vsize[1];

}

return reinterpret_cast<PyObject *>(varray);

}

#else // fallback if we don't have numpy: copy every element of the given vector

template<typename Numeric>

PyObject* get_array(const std::vector<Numeric>& v)

{

PyObject* list = PyList_New(v.size());

for(size_t i = 0; i < v.size(); ++i) {

PyList_SetItem(list, i, PyFloat_FromDouble(v.at(i)));

}

return list;

}

#endif // WITHOUT_NUMPY

// sometimes, for labels and such, we need string arrays

inline PyObject * get_array(const std::vector<std::string>& strings)

{

PyObject* list = PyList_New(static_cast<Py_ssize_t>(strings.size()));

for (std::size_t i = 0; i < strings.size(); ++i) {

PyList_SetItem(list, static_cast<Py_ssize_t>(i), PyString_FromString(strings[i].c_str()));

}

return list;

}

// not all matplotlib need 2d arrays, some prefer lists of lists

template<typename Numeric>

PyObject* get_listlist(const std::vector<std::vector<Numeric>>& ll)

{

PyObject* listlist = PyList_New(ll.size());

for (std::size_t i = 0; i < ll.size(); ++i) {

PyList_SetItem(listlist, i, get_array(ll[i]));

}

return listlist;

}

// Keyword values are given as strings, but some matplotlib options only accept

// numbers. For those keys, a value that is entirely numeric is passed as a

// float, e.g. {"linewidth", "0.4"}; all other values are passed as strings,

// so colors like "0.5", labels like "1" or fontsize "large" are unchanged.

inline PyObject* keyword_value(const std::string& key, const std::string& value)

{

static const char* const numeric_keys[] = {

"alpha", "linewidth", "lw", "linewidths", "markersize", "ms",

"markeredgewidth", "mew", "zorder", "width", "widths", "scale", "headwidth",

"headlength", "headaxislength", "capsize", "elinewidth", "rotation",

"fontsize", "s", "shrink", "aspect", "fraction", "pad"

};

for (std::size_t i = 0; i < sizeof(numeric_keys) / sizeof(numeric_keys[0]); ++i) {

if (key != numeric_keys[i])

continue;

try {

std::size_t pos;

double d = std::stod(value, &pos);

if (pos == value.size())

return PyFloat_FromDouble(d);

} catch (const std::invalid_argument&) {

} catch (const std::out_of_range&) {

}

break;

}

return PyString_FromString(value.c_str());

}

// build a kwargs dict for text properties, e.g. rotation = 45

inline PyObject* text_kwargs(const std::map<std::string, std::string>& keywords)

{

PyObject* kwargs = PyDict_New();

for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {

PyObject* value = keyword_value(it->first, it->second);

PyDict_SetItemString(kwargs, it->first.c_str(), value);

Py_DECREF(value);

}

return kwargs;

}

} // namespace detail

/// Plot a line through the given x and y data points..

///

/// See: https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.plot.html

template<typename Numeric>

bool plot(const std::vector<Numeric> &x, 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(), detail::keyword_value(it->first, it->second));

}

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 bool(res);

}

namespace detail {

// matplotlib >= 3.6 no longer accepts `gca(projection=...)`, so reuse the

// figure's current axes if it is already 3D, or add a new 3D subplot.

// Returns a new reference to the axes.

inline PyObject* init_3d_axis(PyObject* fig)

{

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

if (!axes) throw std::runtime_error("No axes");

Py_ssize_t naxes = PyObject_Length(axes);

Py_DECREF(axes);

if (naxes < 0) throw std::runtime_error("Failed to get number of axes");

if (naxes > 0) {

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

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

PyObject *axis = PyObject_CallObject(gca, _interpreter::get().s_python_empty_tuple);

Py_DECREF(gca);

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

bool is_3d = false;

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

if (name) {

#if PY_MAJOR_VERSION >= 3

is_3d = PyUnicode_Check(name) && PyUnicode_CompareWithASCIIString(name, "3d") == 0;

#else

const char *s = PyString_AsString(name);

is_3d = s && std::string(s) == "3d";

#endif

Py_DECREF(name);

}

PyErr_Clear();

if (is_3d) return axis;

Py_DECREF(axis);

}

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

if (!add_subplot) throw std::runtime_error("No add_subplot");

PyObject *kwargs = PyDict_New();

PyObject *projection = PyString_FromString("3d");

PyDict_SetItemString(kwargs, "projection", projection);

Py_DECREF(projection);

PyObject *axis = PyObject_Call(add_subplot, _interpreter::get().s_python_empty_tuple, kwargs);

Py_DECREF(add_subplot);

Py_DECREF(kwargs);

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

return axis;

}

// Get the figure that a 3D plot function draws into. A fig_number of 0 means

// the current figure (pyplot's gcf(), which creates one if none exists).

// Otherwise the given figure is used if it exists, and a new figure is

// created if it does not. Returns a new reference to the figure.

inline PyObject* get_3d_figure(const long fig_number)

{

PyObject *fig = nullptr;

if (fig_number == 0) {

fig = PyObject_CallObject(_interpreter::get().s_python_function_gcf,

_interpreter::get().s_python_empty_tuple);

if (!fig) throw std::runtime_error("Call to gcf() failed.");

return fig;

}

PyObject *fig_args = PyTuple_New(1);

PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));

PyObject *fig_exists =

PyObject_CallObject(_interpreter::get().s_python_function_fignum_exists, fig_args);

if (!fig_exists) {

Py_DECREF(fig_args);

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

}

if (!PyObject_IsTrue(fig_exists)) {

fig = PyObject_CallObject(_interpreter::get().s_python_function_figure,

_interpreter::get().s_python_empty_tuple);

} else {

fig = PyObject_CallObject(_interpreter::get().s_python_function_figure,

fig_args);

}

Py_DECREF(fig_exists);

Py_DECREF(fig_args);

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

return fig;

}

} // namespace detail

// TODO - it should be possible to make this work by implementing

// a non-numpy alternative for `detail::get_2darray()`.

#ifndef WITHOUT_NUMPY

template <typename Numeric>

void plot_surface(const std::vector<::std::vector<Numeric>> &x,

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>(),

const long fig_number=0)

{

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) {

if (it->first == "linewidth" || it->first == "alpha") {

PyDict_SetItemString(kwargs, it->first.c_str(),

PyFloat_FromDouble(std::stod(it->second)));

} else {

PyDict_SetItemString(kwargs, it->first.c_str(),

detail::keyword_value(it->first, it->second));

}

}

PyObject *fig = detail::get_3d_figure(fig_number);

PyObject *axis = detail::init_3d_axis(fig);

Py_DECREF(fig);

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

if (!plot_surface) throw std::runtime_error("No 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);

}

template <typename Numeric>

void contour(const std::vector<::std::vector<Numeric>> &x,

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

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

const std::map<std::string, std::string> &keywords = {})

{

detail::_interpreter::get();

// 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();

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(),

detail::keyword_value(it->first, it->second));

}

PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_contour, args, kwargs);

if (!res)

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

Py_DECREF(args);

Py_DECREF(kwargs);

if (res) Py_DECREF(res);

}

template <typename Numeric>

void contourf(const std::vector<::std::vector<Numeric>> &x,

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

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

const std::map<std::string, std::string> &keywords = {})

{

detail::_interpreter::get();

// 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();

PyObject *python_colormap_coolwarm = PyObject_GetAttrString(

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

PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);

Py_DECREF(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(),

detail::keyword_value(it->first, it->second));

}

PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_contourf, args, kwargs);

Py_DECREF(args);

Py_DECREF(kwargs);

if (!res)

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

Py_DECREF(res);

}

template <typename Numeric>

void spy(const std::vector<::std::vector<Numeric>> &x,

const double markersize = -1, // -1 for default matplotlib size

const std::map<std::string, std::string> &keywords = {})

{

detail::_interpreter::get();

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

PyObject *kwargs = PyDict_New();

if (markersize != -1) {

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

}

for (std::map<std::string, std::string>::const_iterator it = keywords.begin();

it != keywords.end(); ++it) {

PyDict_SetItemString(kwargs, it->first.c_str(),

detail::keyword_value(it->first, it->second));

}

PyObject *plot_args = PyTuple_New(1);

PyTuple_SetItem(plot_args, 0, xarray);

PyObject *res = PyObject_Call(

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

Py_DECREF(plot_args);

Py_DECREF(kwargs);

if (res) Py_DECREF(res);

}

#endif // WITHOUT_NUMPY

template <typename Numeric>

void plot3(const std::vector<Numeric> &x,

const std::vector<Numeric> &y,

const std::vector<Numeric> &z,

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

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

const long fig_number=0)

{

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!"); }

}

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(),

detail::keyword_value(it->first, it->second));

}

PyObject *fig = detail::get_3d_figure(fig_number);

PyObject *axis = detail::init_3d_axis(fig);

Py_DECREF(fig);

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

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

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);

}

template<typename Numeric>

bool stem(const std::vector<Numeric> &x, 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(),

detail::keyword_value(it->first, it->second));

}

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;

}

template< typename Numeric >

bool fill(const std::vector<Numeric>& x, 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(), detail::keyword_value(it->first, it->second));

}

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;

}

template< typename Numeric >

bool fill_between(const std::vector<Numeric>& x, 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);