
// Python headers must be included before any system headers, since
#ifndef MATPLOTLIBCPP_H_
#define MATPLOTLIBCPP_H_
// they define _POSIX_C_SOURCE
#include <Python.h>

#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>
#endif // WITH_OPENCV

/*
 * 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 // 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_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_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
                    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;

#if PY_MAJOR_VERSION >= 3
                    PySys_SetArgv(argc, const_cast<wchar_t **>(argv));
#else
                    PySys_SetArgv(argc, (char **)(argv));
#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)
                    {
                         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_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_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 res;
     }

     namespace detail
     {

#ifndef WITHOUT_NUMPY
          // Type selector for numpy array conversion
          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<int8_t>
          {
               const static NPY_TYPES type = NPY_INT8;
          };
          template <>
          struct select_npy_type<int16_t>
          {
               const static NPY_TYPES type = NPY_SHORT;
          };
          template <>
          struct select_npy_type<int32_t>
          {
               const static NPY_TYPES type = NPY_INT;
          };
          template <>
          struct select_npy_type<int64_t>
          {
               const static NPY_TYPES type = NPY_INT64;
          };
          template <>
          struct select_npy_type<uint8_t>
          {
               const static NPY_TYPES type = NPY_UINT8;
          };
          template <>
          struct select_npy_type<uint16_t>
          {
               const static NPY_TYPES type = NPY_USHORT;
          };
          template <>
          struct select_npy_type<uint32_t>
          {
               const static NPY_TYPES type = NPY_ULONG;
          };
          template <>
          struct select_npy_type<uint64_t>
          {
               const static NPY_TYPES type = NPY_UINT64;
          };

          // Sanity checks; comment them out or change the numpy type below if you're compiling on
          // a platform where they don't apply
          static_assert(sizeof(long long) == 8);
          template <>
          struct select_npy_type<long long>
          {
               const static NPY_TYPES type = NPY_INT64;
          };
          static_assert(sizeof(unsigned long long) == 8);
          template <>
          struct select_npy_type<unsigned long long>
          {
               const static NPY_TYPES type = NPY_UINT64;
          };

          template <typename Numeric>
          PyObject *get_array(const std::vector<Numeric> &v)
          {
               npy_intp vsize = 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(strings.size());
               for (std::size_t i = 0; i < strings.size(); ++i)
               {
                    PyList_SetItem(list, 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;
          }

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

// 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(),
                                         PyString_FromString(it->second.c_str()));
               }
          }

          PyObject *fig_args = PyTuple_New(1);
          PyObject *fig = nullptr;
          PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
          PyObject *fig_exists =
              PyObject_CallObject(
                  detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
          if (!PyObject_IsTrue(fig_exists))
          {
               fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
                                         detail::_interpreter::get().s_python_empty_tuple);
          }
          else
          {
               fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
                                         fig_args);
          }
          Py_DECREF(fig_exists);
          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);
     }

     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(),
                                    PyString_FromString(it->second.c_str()));
          }

          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 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(),
                                    PyString_FromString(it->second.c_str()));
          }

          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(),
                                    PyString_FromString(it->second.c_str()));
          }

          PyObject *fig_args = PyTuple_New(1);
          PyObject *fig = nullptr;
          PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
          PyObject *fig_exists =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
          if (!PyObject_IsTrue(fig_exists))
          {
               fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
                                         detail::_interpreter::get().s_python_empty_tuple);
          }
          else
          {
               fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
                                         fig_args);
          }
          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 *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);
     }

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

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

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

          // 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;
     }

     template <typename Numeric>
     bool arrow(Numeric x, 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;
     }

     template <typename Numeric>
     bool hist(const std::vector<Numeric> &y, 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;
     }

#ifndef WITHOUT_NUMPY
     namespace detail
     {

          inline void imshow(void *ptr, 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();

               // construct args
               npy_intp dims[3] = {rows, columns, colors};
               PyObject *args = PyTuple_New(1);
               PyTuple_SetItem(args, 0, PyArray_SimpleNewFromData(colors == 1 ? 2 : 3, dims, type, ptr));

               // 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_imshow, args, kwargs);
               Py_DECREF(args);
               Py_DECREF(kwargs);
               if (!res)
                    throw std::runtime_error("Call to imshow() failed");
               if (out)
                    *out = res;
               else
                    Py_DECREF(res);
          }

     } // namespace detail

     inline void imshow(const unsigned char *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject **out = nullptr)
     {
          detail::imshow((void *)ptr, NPY_UINT8, rows, columns, colors, keywords, out);
     }

     inline void imshow(const float *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject **out = nullptr)
     {
          detail::imshow((void *)ptr, NPY_FLOAT, rows, columns, colors, keywords, out);
     }

#ifdef WITH_OPENCV
     void imshow(const cv::Mat &image, const std::map<std::string, std::string> &keywords = {})
     {
          // Convert underlying type of matrix, if needed
          cv::Mat image2;
          NPY_TYPES npy_type = NPY_UINT8;
          switch (image.type() & CV_MAT_DEPTH_MASK)
          {
          case CV_8U:
               image2 = image;
               break;
          case CV_32F:
               image2 = image;
               npy_type = NPY_FLOAT;
               break;
          default:
               image.convertTo(image2, CV_MAKETYPE(CV_8U, image.channels()));
          }

          // If color image, convert from BGR to RGB
          switch (image2.channels())
          {
          case 3:
               cv::cvtColor(image2, image2, CV_BGR2RGB);
               break;
          case 4:
               cv::cvtColor(image2, image2, CV_BGRA2RGBA);
          }

          detail::imshow(image2.data, npy_type, image2.rows, image2.cols, image2.channels(), keywords);
     }
#endif // WITH_OPENCV
#endif // WITHOUT_NUMPY

     template <typename NumericX, typename NumericY>
     bool scatter(const std::vector<NumericX> &x,
                  const std::vector<NumericY> &y,
                  const double s = 1.0, // The marker size in points**2
                  const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

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

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

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
          for (const auto &it : keywords)
          {
               PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
          }

          PyObject *plot_args = PyTuple_New(2);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);

          Py_DECREF(plot_args);
          Py_DECREF(kwargs);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY, typename NumericColors>
     bool scatter_colored(const std::vector<NumericX> &x,
                          const std::vector<NumericY> &y,
                          const std::vector<NumericColors> &colors,
                          const double s = 1.0, // The marker size in points**2
                          const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

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

          PyObject *xarray = detail::get_array(x);
          PyObject *yarray = detail::get_array(y);
          PyObject *colors_array = detail::get_array(colors);

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
          PyDict_SetItemString(kwargs, "c", colors_array);

          for (const auto &it : keywords)
          {
               PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
          }

          PyObject *plot_args = PyTuple_New(2);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);

          Py_DECREF(plot_args);
          Py_DECREF(kwargs);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY, typename NumericZ>
     bool scatter(const std::vector<NumericX> &x,
                  const std::vector<NumericY> &y,
                  const std::vector<NumericZ> &z,
                  const double s = 1.0, // The marker size in points**2
                  const std::map<std::string, std::string> &keywords = {},
                  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(),
                                    PyString_FromString(it->second.c_str()));
          }
          PyObject *fig_args = PyTuple_New(1);
          PyObject *fig = nullptr;
          PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
          PyObject *fig_exists =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
          if (!PyObject_IsTrue(fig_exists))
          {
               fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
                                         detail::_interpreter::get().s_python_empty_tuple);
          }
          else
          {
               fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
                                         fig_args);
          }
          Py_DECREF(fig_exists);
          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 *plot3 = PyObject_GetAttrString(axis, "scatter");
          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);
          Py_DECREF(fig);
          if (res)
               Py_DECREF(res);
          return res;
     }

     template <typename Numeric>
     bool boxplot(const std::vector<std::vector<Numeric>> &data,
                  const std::vector<std::string> &labels = {},
                  const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *listlist = detail::get_listlist(data);
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, listlist);

          PyObject *kwargs = PyDict_New();

          // kwargs needs the labels, if there are (the correct number of) labels
          if (!labels.empty() && labels.size() == data.size())
          {
               PyDict_SetItemString(kwargs, "labels", detail::get_array(labels));
          }

          // take care of the remaining keywords
          for (const auto &it : keywords)
          {
               PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
          }

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

          Py_DECREF(args);
          Py_DECREF(kwargs);

          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename Numeric>
     bool boxplot(const std::vector<Numeric> &data,
                  const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *vector = detail::get_array(data);
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, vector);

          PyObject *kwargs = PyDict_New();
          for (const auto &it : keywords)
          {
               PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
          }

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

          Py_DECREF(args);
          Py_DECREF(kwargs);

          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename Numeric>
     bool bar(const std::vector<Numeric> &x,
              const std::vector<Numeric> &y,
              std::string ec = "black",
              std::string ls = "-",
              double lw = 1.0,
              const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

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

          PyObject *kwargs = PyDict_New();

          PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
          PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
          PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));

          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 *plot_args = PyTuple_New(2);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);

          PyObject *res = PyObject_Call(
              detail::_interpreter::get().s_python_function_bar, plot_args, kwargs);

          Py_DECREF(plot_args);
          Py_DECREF(kwargs);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename Numeric>
     bool bar(const std::vector<Numeric> &y,
              std::string ec = "black",
              std::string ls = "-",
              double lw = 1.0,
              const std::map<std::string, std::string> &keywords = {})
     {
          using T = typename std::remove_reference<decltype(y)>::type::value_type;

          detail::_interpreter::get();

          std::vector<T> x;
          for (std::size_t i = 0; i < y.size(); i++)
          {
               x.push_back(i);
          }

          return bar(x, y, ec, ls, lw, keywords);
     }

     template <typename Numeric>
     bool barh(const std::vector<Numeric> &x, const std::vector<Numeric> &y, std::string ec = "black", std::string ls = "-", double lw = 1.0, const std::map<std::string, std::string> &keywords = {})
     {
          PyObject *xarray = detail::get_array(x);
          PyObject *yarray = detail::get_array(y);

          PyObject *kwargs = PyDict_New();

          PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
          PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
          PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));

          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 *plot_args = PyTuple_New(2);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_barh, plot_args, kwargs);

          Py_DECREF(plot_args);
          Py_DECREF(kwargs);
          if (res)
               Py_DECREF(res);

          return res;
     }

     inline bool subplots_adjust(const std::map<std::string, double> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *kwargs = PyDict_New();
          for (std::map<std::string, double>::const_iterator it =
                   keywords.begin();
               it != keywords.end(); ++it)
          {
               PyDict_SetItemString(kwargs, it->first.c_str(),
                                    PyFloat_FromDouble(it->second));
          }

          PyObject *plot_args = PyTuple_New(0);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_subplots_adjust, plot_args, kwargs);

          Py_DECREF(plot_args);
          Py_DECREF(kwargs);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename Numeric>
     bool named_hist(std::string label, const std::vector<Numeric> &y, long bins = 10, std::string color = "b", double alpha = 1.0)
     {
          detail::_interpreter::get();

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

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "label", PyString_FromString(label.c_str()));
          PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
          PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
          PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));

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

     template <typename NumericX, typename NumericY>
     bool plot(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &s = "")
     {
          assert(x.size() == y.size());

          detail::_interpreter::get();

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

          PyObject *pystring = PyString_FromString(s.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);

          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY, typename NumericZ>
     bool contour(const std::vector<NumericX> &x, const std::vector<NumericY> &y,
                  const std::vector<NumericZ> &z,
                  const std::map<std::string, std::string> &keywords = {})
     {
          assert(x.size() == y.size() && x.size() == z.size());

          PyObject *xarray = detail::get_array(x);
          PyObject *yarray = detail::get_array(y);
          PyObject *zarray = detail::get_array(z);

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, zarray);

          // 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_contour, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY, typename NumericU, typename NumericW>
     bool quiver(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericU> &u, const std::vector<NumericW> &w, const std::map<std::string, std::string> &keywords = {})
     {
          assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size());

          detail::_interpreter::get();

          PyObject *xarray = detail::get_array(x);
          PyObject *yarray = detail::get_array(y);
          PyObject *uarray = detail::get_array(u);
          PyObject *warray = detail::get_array(w);

          PyObject *plot_args = PyTuple_New(4);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, uarray);
          PyTuple_SetItem(plot_args, 3, warray);

          // 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_quiver, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY, typename NumericZ, typename NumericU, typename NumericW, typename NumericV>
     bool quiver(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericZ> &z, const std::vector<NumericU> &u, const std::vector<NumericW> &w, const std::vector<NumericV> &v, const std::map<std::string, std::string> &keywords = {})
     {
          // set up 3d axes stuff
          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 sizes match up
          assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size() && x.size() == z.size() && x.size() == v.size() && u.size() == v.size());

          // set up parameters
          detail::_interpreter::get();

          PyObject *xarray = detail::get_array(x);
          PyObject *yarray = detail::get_array(y);
          PyObject *zarray = detail::get_array(z);
          PyObject *uarray = detail::get_array(u);
          PyObject *warray = detail::get_array(w);
          PyObject *varray = detail::get_array(v);

          PyObject *plot_args = PyTuple_New(6);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, zarray);
          PyTuple_SetItem(plot_args, 3, uarray);
          PyTuple_SetItem(plot_args, 4, warray);
          PyTuple_SetItem(plot_args, 5, varray);

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

          // get figure gca to enable 3d projection
          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);

          // plot our boys bravely, plot them strongly, plot them with a wink and clap
          PyObject *plot3 = PyObject_GetAttrString(axis, "quiver");
          if (!plot3)
               throw std::runtime_error("No 3D line plot");
          Py_INCREF(plot3);
          PyObject *res = PyObject_Call(
              plot3, plot_args, kwargs);
          if (!res)
               throw std::runtime_error("Failed 3D plot");
          Py_DECREF(plot3);
          Py_DECREF(axis);
          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool stem(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &s = "")
     {
          assert(x.size() == y.size());

          detail::_interpreter::get();

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

          PyObject *pystring = PyString_FromString(s.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_CallObject(
              detail::_interpreter::get().s_python_function_stem, plot_args);

          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool semilogx(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &s = "")
     {
          assert(x.size() == y.size());

          detail::_interpreter::get();

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

          PyObject *pystring = PyString_FromString(s.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogx, plot_args);

          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool semilogy(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &s = "")
     {
          assert(x.size() == y.size());

          detail::_interpreter::get();

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

          PyObject *pystring = PyString_FromString(s.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogy, plot_args);

          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool loglog(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &s = "")
     {
          assert(x.size() == y.size());

          detail::_interpreter::get();

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

          PyObject *pystring = PyString_FromString(s.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_loglog, plot_args);

          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool errorbar(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericX> &yerr, const std::map<std::string, std::string> &keywords = {})
     {
          assert(x.size() == y.size());

          detail::_interpreter::get();

          PyObject *xarray = detail::get_array(x);
          PyObject *yarray = detail::get_array(y);
          PyObject *yerrarray = detail::get_array(yerr);

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

          PyDict_SetItemString(kwargs, "yerr", yerrarray);

          PyObject *plot_args = PyTuple_New(2);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_errorbar, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);

          if (res)
               Py_DECREF(res);
          else
               throw std::runtime_error("Call to errorbar() failed.");

          return res;
     }

     template <typename Numeric>
     bool named_plot(const std::string &name, const std::vector<Numeric> &y, const std::string &format = "")
     {
          detail::_interpreter::get();

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));

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

          PyObject *pystring = PyString_FromString(format.c_str());

          PyObject *plot_args = PyTuple_New(2);

          PyTuple_SetItem(plot_args, 0, yarray);
          PyTuple_SetItem(plot_args, 1, pystring);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool named_plot(const std::string &name, const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &format = "")
     {
          detail::_interpreter::get();

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));

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

          PyObject *pystring = PyString_FromString(format.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool named_semilogx(const std::string &name, const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &format = "")
     {
          detail::_interpreter::get();

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));

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

          PyObject *pystring = PyString_FromString(format.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogx, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool named_semilogy(const std::string &name, const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &format = "")
     {
          detail::_interpreter::get();

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));

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

          PyObject *pystring = PyString_FromString(format.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogy, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename NumericX, typename NumericY>
     bool named_loglog(const std::string &name, const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::string &format = "")
     {
          detail::_interpreter::get();

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));

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

          PyObject *pystring = PyString_FromString(format.c_str());

          PyObject *plot_args = PyTuple_New(3);
          PyTuple_SetItem(plot_args, 0, xarray);
          PyTuple_SetItem(plot_args, 1, yarray);
          PyTuple_SetItem(plot_args, 2, pystring);
          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_loglog, plot_args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(plot_args);
          if (res)
               Py_DECREF(res);

          return res;
     }

     template <typename Numeric>
     bool plot(const std::vector<Numeric> &y, const std::string &format = "")
     {
          std::vector<Numeric> x(y.size());
          for (size_t i = 0; i < x.size(); ++i)
               x.at(i) = i;
          return plot(x, y, format);
     }

     template <typename Numeric>
     bool plot(const std::vector<Numeric> &y, const std::map<std::string, std::string> &keywords)
     {
          std::vector<Numeric> x(y.size());
          for (size_t i = 0; i < x.size(); ++i)
               x.at(i) = i;
          return plot(x, y, keywords);
     }

     template <typename Numeric>
     bool stem(const std::vector<Numeric> &y, const std::string &format = "")
     {
          std::vector<Numeric> x(y.size());
          for (size_t i = 0; i < x.size(); ++i)
               x.at(i) = i;
          return stem(x, y, format);
     }

     template <typename Numeric>
     void text(Numeric x, Numeric y, const std::string &s = "")
     {
          detail::_interpreter::get();

          PyObject *args = PyTuple_New(3);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
          PyTuple_SetItem(args, 1, PyFloat_FromDouble(y));
          PyTuple_SetItem(args, 2, PyString_FromString(s.c_str()));

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_text, args);
          if (!res)
               throw std::runtime_error("Call to text() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void colorbar(PyObject *mappable = NULL, const std::map<std::string, float> &keywords = {})
     {
          if (mappable == NULL)
               throw std::runtime_error("Must call colorbar with PyObject* returned from an image, contour, surface, etc.");

          detail::_interpreter::get();

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, mappable);

          PyObject *kwargs = PyDict_New();
          for (std::map<std::string, float>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
          {
               PyDict_SetItemString(kwargs, it->first.c_str(), PyFloat_FromDouble(it->second));
          }

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_colorbar, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to colorbar() failed.");

          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     inline long figure(long number = -1)
     {
          detail::_interpreter::get();

          PyObject *res;
          if (number == -1)
               res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, detail::_interpreter::get().s_python_empty_tuple);
          else
          {
               assert(number > 0);

               // Make sure interpreter is initialised
               detail::_interpreter::get();

               PyObject *args = PyTuple_New(1);
               PyTuple_SetItem(args, 0, PyLong_FromLong(number));
               res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, args);
               Py_DECREF(args);
          }

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

          PyObject *num = PyObject_GetAttrString(res, "number");
          if (!num)
               throw std::runtime_error("Could not get number attribute of figure object");
          const long figureNumber = PyLong_AsLong(num);

          Py_DECREF(num);
          Py_DECREF(res);

          return figureNumber;
     }

     inline bool fignum_exists(long number)
     {
          detail::_interpreter::get();

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyLong_FromLong(number));
          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, args);
          if (!res)
               throw std::runtime_error("Call to fignum_exists() failed.");

          bool ret = PyObject_IsTrue(res);
          Py_DECREF(res);
          Py_DECREF(args);

          return ret;
     }

     inline void figure_size(size_t w, size_t h)
     {
          detail::_interpreter::get();

          const size_t dpi = 100;
          PyObject *size = PyTuple_New(2);
          PyTuple_SetItem(size, 0, PyFloat_FromDouble((double)w / dpi));
          PyTuple_SetItem(size, 1, PyFloat_FromDouble((double)h / dpi));

          PyObject *kwargs = PyDict_New();
          PyDict_SetItemString(kwargs, "figsize", size);
          PyDict_SetItemString(kwargs, "dpi", PyLong_FromSize_t(dpi));

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_figure,
                                        detail::_interpreter::get().s_python_empty_tuple, kwargs);

          Py_DECREF(kwargs);

          if (!res)
               throw std::runtime_error("Call to figure_size() failed.");
          Py_DECREF(res);
     }

     inline void legend()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple);
          if (!res)
               throw std::runtime_error("Call to legend() failed.");

          Py_DECREF(res);
     }

     inline void legend(const std::map<std::string, std::string> &keywords)
     {
          detail::_interpreter::get();

          // 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_legend, detail::_interpreter::get().s_python_empty_tuple, kwargs);
          if (!res)
               throw std::runtime_error("Call to legend() failed.");

          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     template <typename Numeric>
     inline void set_aspect(Numeric ratio)
     {
          detail::_interpreter::get();

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(ratio));
          PyObject *kwargs = PyDict_New();

          PyObject *ax =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
                                  detail::_interpreter::get().s_python_empty_tuple);
          if (!ax)
               throw std::runtime_error("Call to gca() failed.");
          Py_INCREF(ax);

          PyObject *set_aspect = PyObject_GetAttrString(ax, "set_aspect");
          if (!set_aspect)
               throw std::runtime_error("Attribute set_aspect not found.");
          Py_INCREF(set_aspect);

          PyObject *res = PyObject_Call(set_aspect, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to set_aspect() failed.");
          Py_DECREF(set_aspect);

          Py_DECREF(ax);
          Py_DECREF(args);
          Py_DECREF(kwargs);
     }

     inline void set_aspect_equal()
     {
          // expect ratio == "equal". Leaving error handling to matplotlib.
          detail::_interpreter::get();

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyString_FromString("equal"));
          PyObject *kwargs = PyDict_New();

          PyObject *ax =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
                                  detail::_interpreter::get().s_python_empty_tuple);
          if (!ax)
               throw std::runtime_error("Call to gca() failed.");
          Py_INCREF(ax);

          PyObject *set_aspect = PyObject_GetAttrString(ax, "set_aspect");
          if (!set_aspect)
               throw std::runtime_error("Attribute set_aspect not found.");
          Py_INCREF(set_aspect);

          PyObject *res = PyObject_Call(set_aspect, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to set_aspect() failed.");
          Py_DECREF(set_aspect);

          Py_DECREF(ax);
          Py_DECREF(args);
          Py_DECREF(kwargs);
     }

     template <typename Numeric>
     void ylim(Numeric left, Numeric right)
     {
          detail::_interpreter::get();

          PyObject *list = PyList_New(2);
          PyList_SetItem(list, 0, PyFloat_FromDouble(left));
          PyList_SetItem(list, 1, PyFloat_FromDouble(right));

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, list);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
          if (!res)
               throw std::runtime_error("Call to ylim() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     template <typename Numeric>
     void xlim(Numeric left, Numeric right)
     {
          detail::_interpreter::get();

          PyObject *list = PyList_New(2);
          PyList_SetItem(list, 0, PyFloat_FromDouble(left));
          PyList_SetItem(list, 1, PyFloat_FromDouble(right));

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, list);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
          if (!res)
               throw std::runtime_error("Call to xlim() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline std::array<double, 2> xlim()
     {
          PyObject *args = PyTuple_New(0);
          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);

          if (!res)
               throw std::runtime_error("Call to xlim() failed.");

          Py_DECREF(res);

          PyObject *left = PyTuple_GetItem(res, 0);
          PyObject *right = PyTuple_GetItem(res, 1);
          return {PyFloat_AsDouble(left), PyFloat_AsDouble(right)};
     }

     inline std::array<double, 2> ylim()
     {
          PyObject *args = PyTuple_New(0);
          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);

          if (!res)
               throw std::runtime_error("Call to ylim() failed.");

          Py_DECREF(res);

          PyObject *left = PyTuple_GetItem(res, 0);
          PyObject *right = PyTuple_GetItem(res, 1);
          return {PyFloat_AsDouble(left), PyFloat_AsDouble(right)};
     }

     template <typename Numeric>
     inline void xticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string> &keywords = {})
     {
          assert(labels.size() == 0 || ticks.size() == labels.size());

          detail::_interpreter::get();

          // using numpy array
          PyObject *ticksarray = detail::get_array(ticks);

          PyObject *args;
          if (labels.size() == 0)
          {
               // construct positional args
               args = PyTuple_New(1);
               PyTuple_SetItem(args, 0, ticksarray);
          }
          else
          {
               // make tuple of tick labels
               PyObject *labelstuple = PyTuple_New(labels.size());
               for (size_t i = 0; i < labels.size(); i++)
                    PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));

               // construct positional args
               args = PyTuple_New(2);
               PyTuple_SetItem(args, 0, ticksarray);
               PyTuple_SetItem(args, 1, labelstuple);
          }

          // 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_xticks, args, kwargs);

          Py_DECREF(args);
          Py_DECREF(kwargs);
          if (!res)
               throw std::runtime_error("Call to xticks() failed");

          Py_DECREF(res);
     }

     template <typename Numeric>
     inline void xticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string> &keywords)
     {
          xticks(ticks, {}, keywords);
     }

     template <typename Numeric>
     inline void yticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string> &keywords = {})
     {
          assert(labels.size() == 0 || ticks.size() == labels.size());

          detail::_interpreter::get();

          // using numpy array
          PyObject *ticksarray = detail::get_array(ticks);

          PyObject *args;
          if (labels.size() == 0)
          {
               // construct positional args
               args = PyTuple_New(1);
               PyTuple_SetItem(args, 0, ticksarray);
          }
          else
          {
               // make tuple of tick labels
               PyObject *labelstuple = PyTuple_New(labels.size());
               for (size_t i = 0; i < labels.size(); i++)
                    PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));

               // construct positional args
               args = PyTuple_New(2);
               PyTuple_SetItem(args, 0, ticksarray);
               PyTuple_SetItem(args, 1, labelstuple);
          }

          // 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_yticks, args, kwargs);

          Py_DECREF(args);
          Py_DECREF(kwargs);
          if (!res)
               throw std::runtime_error("Call to yticks() failed");

          Py_DECREF(res);
     }

     template <typename Numeric>
     inline void yticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string> &keywords)
     {
          yticks(ticks, {}, keywords);
     }

     template <typename Numeric>
     inline void margins(Numeric margin)
     {
          // construct positional args
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin));

          PyObject *res =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
          if (!res)
               throw std::runtime_error("Call to margins() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     template <typename Numeric>
     inline void margins(Numeric margin_x, Numeric margin_y)
     {
          // construct positional args
          PyObject *args = PyTuple_New(2);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin_x));
          PyTuple_SetItem(args, 1, PyFloat_FromDouble(margin_y));

          PyObject *res =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
          if (!res)
               throw std::runtime_error("Call to margins() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void tick_params(const std::map<std::string, std::string> &keywords, const std::string axis = "both")
     {
          detail::_interpreter::get();

          // construct positional args
          PyObject *args;
          args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyString_FromString(axis.c_str()));

          // 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_tick_params, args, kwargs);

          Py_DECREF(args);
          Py_DECREF(kwargs);
          if (!res)
               throw std::runtime_error("Call to tick_params() failed");

          Py_DECREF(res);
     }

     inline void subplot(long nrows, long ncols, long plot_number)
     {
          detail::_interpreter::get();

          // construct positional args
          PyObject *args = PyTuple_New(3);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(nrows));
          PyTuple_SetItem(args, 1, PyFloat_FromDouble(ncols));
          PyTuple_SetItem(args, 2, PyFloat_FromDouble(plot_number));

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot, args);
          if (!res)
               throw std::runtime_error("Call to subplot() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void subplot2grid(long nrows, long ncols, long rowid = 0, long colid = 0, long rowspan = 1, long colspan = 1)
     {
          detail::_interpreter::get();

          PyObject *shape = PyTuple_New(2);
          PyTuple_SetItem(shape, 0, PyLong_FromLong(nrows));
          PyTuple_SetItem(shape, 1, PyLong_FromLong(ncols));

          PyObject *loc = PyTuple_New(2);
          PyTuple_SetItem(loc, 0, PyLong_FromLong(rowid));
          PyTuple_SetItem(loc, 1, PyLong_FromLong(colid));

          PyObject *args = PyTuple_New(4);
          PyTuple_SetItem(args, 0, shape);
          PyTuple_SetItem(args, 1, loc);
          PyTuple_SetItem(args, 2, PyLong_FromLong(rowspan));
          PyTuple_SetItem(args, 3, PyLong_FromLong(colspan));

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot2grid, args);
          if (!res)
               throw std::runtime_error("Call to subplot2grid() failed.");

          Py_DECREF(shape);
          Py_DECREF(loc);
          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void title(const std::string &titlestr, const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *pytitlestr = PyString_FromString(titlestr.c_str());
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pytitlestr);

          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_title, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to title() failed.");

          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     inline void suptitle(const std::string &suptitlestr, const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *pysuptitlestr = PyString_FromString(suptitlestr.c_str());
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pysuptitlestr);

          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_suptitle, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to suptitle() failed.");

          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     inline void axis(const std::string &axisstr)
     {
          detail::_interpreter::get();

          PyObject *str = PyString_FromString(axisstr.c_str());
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, str);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_axis, args);
          if (!res)
               throw std::runtime_error("Call to title() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void axhline(double y, double xmin = 0., double xmax = 1., const std::map<std::string, std::string> &keywords = std::map<std::string, std::string>())
     {
          detail::_interpreter::get();

          // construct positional args
          PyObject *args = PyTuple_New(3);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(y));
          PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmin));
          PyTuple_SetItem(args, 2, PyFloat_FromDouble(xmax));

          // 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_axhline, args, kwargs);

          Py_DECREF(args);
          Py_DECREF(kwargs);

          if (res)
               Py_DECREF(res);
     }

     inline void axvline(double x, double ymin = 0., double ymax = 1., const std::map<std::string, std::string> &keywords = std::map<std::string, std::string>())
     {
          detail::_interpreter::get();

          // construct positional args
          PyObject *args = PyTuple_New(3);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
          PyTuple_SetItem(args, 1, PyFloat_FromDouble(ymin));
          PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymax));

          // 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_axvline, args, kwargs);

          Py_DECREF(args);
          Py_DECREF(kwargs);

          if (res)
               Py_DECREF(res);
     }

     inline void axvspan(double xmin, double xmax, double ymin = 0., double ymax = 1., const std::map<std::string, std::string> &keywords = std::map<std::string, std::string>())
     {
          // construct positional args
          PyObject *args = PyTuple_New(4);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(xmin));
          PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmax));
          PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymin));
          PyTuple_SetItem(args, 3, PyFloat_FromDouble(ymax));

          // construct keyword args
          PyObject *kwargs = PyDict_New();
          for (auto 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(),
                                         PyString_FromString(it->second.c_str()));
               }
          }

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

          if (res)
               Py_DECREF(res);
     }

     inline void xlabel(const std::string &str, const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *pystr = PyString_FromString(str.c_str());
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pystr);

          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_xlabel, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to xlabel() failed.");

          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     inline void ylabel(const std::string &str, const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *pystr = PyString_FromString(str.c_str());
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pystr);

          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_ylabel, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to ylabel() failed.");

          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     inline void set_zlabel(const std::string &str, const std::map<std::string, std::string> &keywords = {})
     {
          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)
          {
               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!");
               }
          }

          PyObject *pystr = PyString_FromString(str.c_str());
          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pystr);

          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 *ax =
              PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
                                  detail::_interpreter::get().s_python_empty_tuple);
          if (!ax)
               throw std::runtime_error("Call to gca() failed.");
          Py_INCREF(ax);

          PyObject *zlabel = PyObject_GetAttrString(ax, "set_zlabel");
          if (!zlabel)
               throw std::runtime_error("Attribute set_zlabel not found.");
          Py_INCREF(zlabel);

          PyObject *res = PyObject_Call(zlabel, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to set_zlabel() failed.");
          Py_DECREF(zlabel);

          Py_DECREF(ax);
          Py_DECREF(args);
          Py_DECREF(kwargs);
          if (res)
               Py_DECREF(res);
     }

     inline void grid(bool flag)
     {
          detail::_interpreter::get();

          PyObject *pyflag = flag ? Py_True : Py_False;
          Py_INCREF(pyflag);

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pyflag);

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_grid, args);
          if (!res)
               throw std::runtime_error("Call to grid() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void show(const bool block = true)
     {
          detail::_interpreter::get();

          PyObject *res;
          if (block)
          {
               res = PyObject_CallObject(
                   detail::_interpreter::get().s_python_function_show,
                   detail::_interpreter::get().s_python_empty_tuple);
          }
          else
          {
               PyObject *kwargs = PyDict_New();
               PyDict_SetItemString(kwargs, "block", Py_False);
               res = PyObject_Call(detail::_interpreter::get().s_python_function_show, detail::_interpreter::get().s_python_empty_tuple, kwargs);
               Py_DECREF(kwargs);
          }

          if (!res)
               throw std::runtime_error("Call to show() failed.");

          Py_DECREF(res);
     }

     inline void close()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(
              detail::_interpreter::get().s_python_function_close,
              detail::_interpreter::get().s_python_empty_tuple);

          if (!res)
               throw std::runtime_error("Call to close() failed.");

          Py_DECREF(res);
     }

     inline void xkcd()
     {
          detail::_interpreter::get();

          PyObject *res;
          PyObject *kwargs = PyDict_New();

          res = PyObject_Call(detail::_interpreter::get().s_python_function_xkcd,
                              detail::_interpreter::get().s_python_empty_tuple, kwargs);

          Py_DECREF(kwargs);

          if (!res)
               throw std::runtime_error("Call to show() failed.");

          Py_DECREF(res);
     }

     inline void draw()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(
              detail::_interpreter::get().s_python_function_draw,
              detail::_interpreter::get().s_python_empty_tuple);

          if (!res)
               throw std::runtime_error("Call to draw() failed.");

          Py_DECREF(res);
     }

     template <typename Numeric>
     inline void pause(Numeric interval)
     {
          detail::_interpreter::get();

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyFloat_FromDouble(interval));

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_pause, args);
          if (!res)
               throw std::runtime_error("Call to pause() failed.");

          Py_DECREF(args);
          Py_DECREF(res);
     }

     inline void save(const std::string &filename, const int dpi = 0)
     {
          detail::_interpreter::get();

          PyObject *pyfilename = PyString_FromString(filename.c_str());

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, pyfilename);

          PyObject *kwargs = PyDict_New();

          if (dpi > 0)
          {
               PyDict_SetItemString(kwargs, "dpi", PyLong_FromLong(dpi));
          }

          PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_save, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to save() failed.");

          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(res);
     }

     inline void rcparams(const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();
          PyObject *args = PyTuple_New(0);
          PyObject *kwargs = PyDict_New();
          for (auto it = keywords.begin(); it != keywords.end(); ++it)
          {
               if ("text.usetex" == it->first)
                    PyDict_SetItemString(kwargs, it->first.c_str(), PyLong_FromLong(std::stoi(it->second.c_str())));
               else
                    PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
          }

          PyObject *update = PyObject_GetAttrString(detail::_interpreter::get().s_python_function_rcparams, "update");
          PyObject *res = PyObject_Call(update, args, kwargs);
          if (!res)
               throw std::runtime_error("Call to rcParams.update() failed.");
          Py_DECREF(args);
          Py_DECREF(kwargs);
          Py_DECREF(update);
          Py_DECREF(res);
     }

     inline void clf()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(
              detail::_interpreter::get().s_python_function_clf,
              detail::_interpreter::get().s_python_empty_tuple);

          if (!res)
               throw std::runtime_error("Call to clf() failed.");

          Py_DECREF(res);
     }

     inline void cla()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_cla,
                                              detail::_interpreter::get().s_python_empty_tuple);

          if (!res)
               throw std::runtime_error("Call to cla() failed.");

          Py_DECREF(res);
     }

     inline void ion()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(
              detail::_interpreter::get().s_python_function_ion,
              detail::_interpreter::get().s_python_empty_tuple);

          if (!res)
               throw std::runtime_error("Call to ion() failed.");

          Py_DECREF(res);
     }

     inline std::vector<std::array<double, 2>> ginput(const int numClicks = 1, const std::map<std::string, std::string> &keywords = {})
     {
          detail::_interpreter::get();

          PyObject *args = PyTuple_New(1);
          PyTuple_SetItem(args, 0, PyLong_FromLong(numClicks));

          // 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_ginput, args, kwargs);

          Py_DECREF(kwargs);
          Py_DECREF(args);
          if (!res)
               throw std::runtime_error("Call to ginput() failed.");

          const size_t len = PyList_Size(res);
          std::vector<std::array<double, 2>> out;
          out.reserve(len);
          for (size_t i = 0; i < len; i++)
          {
               PyObject *current = PyList_GetItem(res, i);
               std::array<double, 2> position;
               position[0] = PyFloat_AsDouble(PyTuple_GetItem(current, 0));
               position[1] = PyFloat_AsDouble(PyTuple_GetItem(current, 1));
               out.push_back(position);
          }
          Py_DECREF(res);

          return out;
     }

     // Actually, is there any reason not to call this automatically for every plot?
     inline void tight_layout()
     {
          detail::_interpreter::get();

          PyObject *res = PyObject_CallObject(
              detail::_interpreter::get().s_python_function_tight_layout,
              detail::_interpreter::get().s_python_empty_tuple);

          if (!res)
               throw std::runtime_error("Call to tight_layout() failed.");

          Py_DECREF(res);
     }

     // Support for variadic plot() and initializer lists:

     namespace detail
     {

          template <typename T>
          using is_function = typename std::is_function<std::remove_pointer<std::remove_reference<T>>>::type;

          template <bool obj, typename T>
          struct is_callable_impl;

          template <typename T>
          struct is_callable_impl<false, T>
          {
               typedef is_function<T> type;
          }; // a non-object is callable iff it is a function

          template <typename T>
          struct is_callable_impl<true, T>
          {
               struct Fallback
               {
                    void operator()();
               };
               struct Derived : T, Fallback
               {
               };

               template <typename U, U>
               struct Check;

               template <typename U>
               static std::true_type test(...); // use a variadic function to make sure (1) it accepts everything and (2) its always the worst match

               template <typename U>
               static std::false_type test(Check<void (Fallback::*)(), &U::operator()> *);

          public:
               typedef decltype(test<Derived>(nullptr)) type;
               typedef decltype(&Fallback::operator()) dtype;
               static constexpr bool value = type::value;
          }; // an object is callable iff it defines operator()

          template <typename T>
          struct is_callable
          {
               // dispatch to is_callable_impl<true, T> or is_callable_impl<false, T> depending on whether T is of class type or not
               typedef typename is_callable_impl<std::is_class<T>::value, T>::type type;
          };

          template <typename IsYDataCallable>
          struct plot_impl
          {
          };

          template <>
          struct plot_impl<std::false_type>
          {
               template <typename IterableX, typename IterableY>
               bool operator()(const IterableX &x, const IterableY &y, const std::string &format)
               {
                    detail::_interpreter::get();

                    // 2-phase lookup for distance, begin, end
                    using std::begin;
                    using std::distance;
                    using std::end;

                    auto xs = distance(begin(x), end(x));
                    auto ys = distance(begin(y), end(y));
                    assert(xs == ys && "x and y data must have the same number of elements!");

                    PyObject *xlist = PyList_New(xs);
                    PyObject *ylist = PyList_New(ys);
                    PyObject *pystring = PyString_FromString(format.c_str());

                    auto itx = begin(x), ity = begin(y);
                    for (size_t i = 0; i < xs; ++i)
                    {
                         PyList_SetItem(xlist, i, PyFloat_FromDouble(*itx++));
                         PyList_SetItem(ylist, i, PyFloat_FromDouble(*ity++));
                    }

                    PyObject *plot_args = PyTuple_New(3);
                    PyTuple_SetItem(plot_args, 0, xlist);
                    PyTuple_SetItem(plot_args, 1, ylist);
                    PyTuple_SetItem(plot_args, 2, pystring);

                    PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);

                    Py_DECREF(plot_args);
                    if (res)
                         Py_DECREF(res);

                    return res;
               }
          };

          template <>
          struct plot_impl<std::true_type>
          {
               template <typename Iterable, typename Callable>
               bool operator()(const Iterable &ticks, const Callable &f, const std::string &format)
               {
                    if (begin(ticks) == end(ticks))
                         return true;

                    // We could use additional meta-programming to deduce the correct element type of y,
                    // but all values have to be convertible to double anyways
                    std::vector<double> y;
                    for (auto x : ticks)
                         y.push_back(f(x));
                    return plot_impl<std::false_type>()(ticks, y, format);
               }
          };

     } // end namespace detail

     // recursion stop for the above
     template <typename... Args>
     bool plot() { return true; }

     template <typename A, typename B, typename... Args>
     bool plot(const A &a, const B &b, const std::string &format, Args... args)
     {
          return detail::plot_impl<typename detail::is_callable<B>::type>()(a, b, format) && plot(args...);
     }

     /*
      * This group of plot() functions is needed to support initializer lists, i.e. calling
      *    plot( {1,2,3,4} )
      */
     inline bool plot(const std::vector<double> &x, const std::vector<double> &y, const std::string &format = "")
     {
          return plot<double, double>(x, y, format);
     }

     inline bool plot(const std::vector<double> &y, const std::string &format = "")
     {
          return plot<double>(y, format);
     }

     inline bool plot(const std::vector<double> &x, const std::vector<double> &y, const std::map<std::string, std::string> &keywords)
     {
          return plot<double>(x, y, keywords);
     }

     /*
      * This class allows dynamic plots, ie changing the plotted data without clearing and re-plotting
      */
     class Plot
     {
     public:
          // default initialization with plot label, some data and format
          template <typename Numeric>
          Plot(const std::string &name, const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::string &format = "")
          {
               detail::_interpreter::get();

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

               PyObject *kwargs = PyDict_New();
               if (name != "")
                    PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));

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

               PyObject *pystring = PyString_FromString(format.c_str());

               PyObject *plot_args = PyTuple_New(3);
               PyTuple_SetItem(plot_args, 0, xarray);
               PyTuple_SetItem(plot_args, 1, yarray);
               PyTuple_SetItem(plot_args, 2, pystring);

               PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);

               Py_DECREF(kwargs);
               Py_DECREF(plot_args);

               if (res)
               {
                    line = PyList_GetItem(res, 0);

                    if (line)
                         set_data_fct = PyObject_GetAttrString(line, "set_data");
                    else
                         Py_DECREF(line);
                    Py_DECREF(res);
               }
          }

          // shorter initialization with name or format only
          // basically calls line, = plot([], [])
          Plot(const std::string &name = "", const std::string &format = "")
              : Plot(name, std::vector<double>(), std::vector<double>(), format) {}

          template <typename Numeric>
          bool update(const std::vector<Numeric> &x, const std::vector<Numeric> &y)
          {
               assert(x.size() == y.size());
               if (set_data_fct)
               {
                    PyObject *xarray = detail::get_array(x);
                    PyObject *yarray = detail::get_array(y);

                    PyObject *plot_args = PyTuple_New(2);
                    PyTuple_SetItem(plot_args, 0, xarray);
                    PyTuple_SetItem(plot_args, 1, yarray);

                    PyObject *res = PyObject_CallObject(set_data_fct, plot_args);
                    if (res)
                         Py_DECREF(res);
                    return res;
               }
               return false;
          }

          // clears the plot but keep it available
          bool clear()
          {
               return update(std::vector<double>(), std::vector<double>());
          }

          // definitely remove this line
          void remove()
          {
               if (line)
               {
                    auto remove_fct = PyObject_GetAttrString(line, "remove");
                    PyObject *args = PyTuple_New(0);
                    PyObject *res = PyObject_CallObject(remove_fct, args);
                    if (res)
                         Py_DECREF(res);
               }
               decref();
          }

          ~Plot()
          {
               decref();
          }

     private:
          void decref()
          {
               if (line)
                    Py_DECREF(line);
               if (set_data_fct)
                    Py_DECREF(set_data_fct);
          }

          PyObject *line = nullptr;
          PyObject *set_data_fct = nullptr;
     };

} // end namespace matplotlibcpp


#endif /* MATPLOTLIBCPP_H_ */
