Loading...
Searching...
No Matches
matplotlibcpp.h
Go to the documentation of this file.
#pragma once
// Python headers must be included before any system headers, since
// 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
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
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, PyLong_FromLong(nrows));
PyTuple_SetItem(args, 1, PyLong_FromLong(ncols));
PyTuple_SetItem(args, 2, PyLong_FromLong(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::distance;
using std::begin;
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
matplotlibcpp::Plot::set_data_fct
PyObject * set_data_fct
Definition matplotlibcpp.h:2983
matplotlibcpp::Plot::clear
bool clear()
Definition matplotlibcpp.h:2953
matplotlibcpp::Plot::Plot
Plot(const std::string &name, const std::vector< Numeric > &x, const std::vector< Numeric > &y, const std::string &format="")
Definition matplotlibcpp.h:2892
matplotlibcpp::Plot::~Plot
~Plot()
Definition matplotlibcpp.h:2969
matplotlibcpp::Plot::Plot
Plot(const std::string &name="", const std::string &format="")
Definition matplotlibcpp.h:2930
matplotlibcpp::Plot::decref
void decref()
Definition matplotlibcpp.h:2974
matplotlibcpp::Plot::update
bool update(const std::vector< Numeric > &x, const std::vector< Numeric > &y)
Definition matplotlibcpp.h:2934
matplotlibcpp::Plot::remove
void remove()
Definition matplotlibcpp.h:2958
matplotlibcpp::Plot::line
PyObject * line
Definition matplotlibcpp.h:2982
matplotlibcpp::detail
Definition matplotlibcpp.h:44
matplotlibcpp::detail::get_listlist
PyObject * get_listlist(const std::vector< std::vector< Numeric > > &ll)
Definition matplotlibcpp.h:427
matplotlibcpp::detail::get_array
PyObject * get_array(const std::vector< Numeric > &v)
Definition matplotlibcpp.h:359
matplotlibcpp::detail::is_function
typename std::is_function< std::remove_pointer< std::remove_reference< T > > >::type is_function
Definition matplotlibcpp.h:2758
matplotlibcpp::detail::get_2darray
PyObject * get_2darray(const std::vector<::std::vector< Numeric > > &v)
Definition matplotlibcpp.h:379
matplotlibcpp::detail::imshow
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)
Definition matplotlibcpp.h:918
matplotlibcpp::detail::s_backend
static std::string s_backend
Definition matplotlibcpp.h:46
matplotlibcpp
Definition matplotlibcpp.h:43
matplotlibcpp::ginput
std::vector< std::array< double, 2 > > ginput(const int numClicks=1, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2704
matplotlibcpp::fill
bool fill(const std::vector< Numeric > &x, const std::vector< Numeric > &y, const std::map< std::string, std::string > &keywords)
Definition matplotlibcpp.h:790
matplotlibcpp::contour
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={})
Definition matplotlibcpp.h:587
matplotlibcpp::plot3
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)
Definition matplotlibcpp.h:660
matplotlibcpp::xlim
std::array< double, 2 > xlim()
Definition matplotlibcpp.h:2067
matplotlibcpp::tight_layout
void tight_layout()
Definition matplotlibcpp.h:2741
matplotlibcpp::scatter
bool scatter(const std::vector< NumericX > &x, const std::vector< NumericY > &y, const double s=1.0, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:993
matplotlibcpp::named_hist
bool named_hist(std::string label, const std::vector< Numeric > &y, long bins=10, std::string color="b", double alpha=1.0)
Definition matplotlibcpp.h:1332
matplotlibcpp::rcparams
void rcparams(const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2649
matplotlibcpp::set_aspect_equal
void set_aspect_equal()
Definition matplotlibcpp.h:2000
matplotlibcpp::figure
long figure(long number=-1)
Definition matplotlibcpp.h:1875
matplotlibcpp::scatter_colored
bool scatter_colored(const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::vector< NumericColors > &colors, const double s=1.0, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:1026
matplotlibcpp::errorbar
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={})
Definition matplotlibcpp.h:1640
matplotlibcpp::margins
void margins(Numeric margin)
Definition matplotlibcpp.h:2194
matplotlibcpp::annotate
bool annotate(std::string annotation, double x, double y)
Definition matplotlibcpp.h:308
matplotlibcpp::imshow
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)
Definition matplotlibcpp.h:950
matplotlibcpp::semilogy
bool semilogy(const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::string &s="")
Definition matplotlibcpp.h:1590
matplotlibcpp::named_semilogy
bool named_semilogy(const std::string &name, const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::string &format="")
Definition matplotlibcpp.h:1757
matplotlibcpp::arrow
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)
Definition matplotlibcpp.h:856
matplotlibcpp::close
void close()
Definition matplotlibcpp.h:2567
matplotlibcpp::fignum_exists
bool fignum_exists(long number)
Definition matplotlibcpp.h:1906
matplotlibcpp::named_plot
bool named_plot(const std::string &name, const std::vector< Numeric > &y, const std::string &format="")
Definition matplotlibcpp.h:1677
matplotlibcpp::tick_params
void tick_params(const std::map< std::string, std::string > &keywords, const std::string axis="both")
Definition matplotlibcpp.h:2226
matplotlibcpp::suptitle
void suptitle(const std::string &suptitlestr, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2317
matplotlibcpp::loglog
bool loglog(const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::string &s="")
Definition matplotlibcpp.h:1615
matplotlibcpp::title
void title(const std::string &titlestr, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2296
matplotlibcpp::axvline
void axvline(double x, double ymin=0., double ymax=1., const std::map< std::string, std::string > &keywords=std::map< std::string, std::string >())
Definition matplotlibcpp.h:2378
matplotlibcpp::bar
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={})
Definition matplotlibcpp.h:1221
matplotlibcpp::subplot
void subplot(long nrows, long ncols, long plot_number)
Definition matplotlibcpp.h:2252
matplotlibcpp::ylim
std::array< double, 2 > ylim()
Definition matplotlibcpp.h:2082
matplotlibcpp::backend
void backend(const std::string &name)
Definition matplotlibcpp.h:303
matplotlibcpp::subplots_adjust
bool subplots_adjust(const std::map< std::string, double > &keywords={})
Definition matplotlibcpp.h:1308
matplotlibcpp::plot
bool plot()
Definition matplotlibcpp.h:2860
matplotlibcpp::legend
void legend()
Definition matplotlibcpp.h:1944
matplotlibcpp::figure_size
void figure_size(size_t w, size_t h)
Definition matplotlibcpp.h:1922
matplotlibcpp::fill_between
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)
Definition matplotlibcpp.h:822
matplotlibcpp::xlabel
void xlabel(const std::string &str, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2431
matplotlibcpp::named_loglog
bool named_loglog(const std::string &name, const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::string &format="")
Definition matplotlibcpp.h:1784
matplotlibcpp::ion
void ion()
Definition matplotlibcpp.h:2692
matplotlibcpp::colorbar
void colorbar(PyObject *mappable=NULL, const std::map< std::string, float > &keywords={})
Definition matplotlibcpp.h:1850
matplotlibcpp::boxplot
bool boxplot(const std::vector< std::vector< Numeric > > &data, const std::vector< std::string > &labels={}, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:1161
matplotlibcpp::cla
void cla()
Definition matplotlibcpp.h:2680
matplotlibcpp::pause
void pause(Numeric interval)
Definition matplotlibcpp.h:2611
matplotlibcpp::axvspan
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 >())
Definition matplotlibcpp.h:2403
matplotlibcpp::spy
void spy(const std::vector<::std::vector< Numeric > > &x, const double markersize=-1, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:629
matplotlibcpp::plot_surface
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)
Definition matplotlibcpp.h:477
matplotlibcpp::axis
void axis(const std::string &axisstr)
Definition matplotlibcpp.h:2338
matplotlibcpp::axhline
void axhline(double y, double xmin=0., double xmax=1., const std::map< std::string, std::string > &keywords=std::map< std::string, std::string >())
Definition matplotlibcpp.h:2353
matplotlibcpp::yticks
void yticks(const std::vector< Numeric > &ticks, const std::vector< std::string > &labels={}, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2146
matplotlibcpp::subplot2grid
void subplot2grid(long nrows, long ncols, long rowid=0, long colid=0, long rowspan=1, long colspan=1)
Definition matplotlibcpp.h:2269
matplotlibcpp::set_zlabel
void set_zlabel(const std::string &str, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2473
matplotlibcpp::set_aspect
void set_aspect(Numeric ratio)
Definition matplotlibcpp.h:1973
matplotlibcpp::show
void show(const bool block=true)
Definition matplotlibcpp.h:2542
matplotlibcpp::xkcd
void xkcd()
Definition matplotlibcpp.h:2580
matplotlibcpp::xticks
void xticks(const std::vector< Numeric > &ticks, const std::vector< std::string > &labels={}, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2097
matplotlibcpp::draw
void draw()
Definition matplotlibcpp.h:2597
matplotlibcpp::save
void save(const std::string &filename, const int dpi=0)
Definition matplotlibcpp.h:2625
matplotlibcpp::semilogx
bool semilogx(const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::string &s="")
Definition matplotlibcpp.h:1565
matplotlibcpp::text
void text(Numeric x, Numeric y, const std::string &s="")
Definition matplotlibcpp.h:1834
matplotlibcpp::ylabel
void ylabel(const std::string &str, const std::map< std::string, std::string > &keywords={})
Definition matplotlibcpp.h:2452
matplotlibcpp::clf
void clf()
Definition matplotlibcpp.h:2668
matplotlibcpp::grid
void grid(bool flag)
Definition matplotlibcpp.h:2525
matplotlibcpp::named_semilogx
bool named_semilogx(const std::string &name, const std::vector< NumericX > &x, const std::vector< NumericY > &y, const std::string &format="")
Definition matplotlibcpp.h:1730
matplotlibcpp::stem
bool stem(const std::vector< Numeric > &x, const std::vector< Numeric > &y, const std::map< std::string, std::string > &keywords)
Definition matplotlibcpp.h:755
matplotlibcpp::hist
bool hist(const std::vector< Numeric > &y, long bins=10, std::string color="b", double alpha=1.0, bool cumulative=false)
Definition matplotlibcpp.h:887
matplotlibcpp::quiver
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={})
Definition matplotlibcpp.h:1416
matplotlibcpp::barh
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={ })
Definition matplotlibcpp.h:1280
matplotlibcpp::detail::_interpreter::s_python_function_axhline
PyObject * s_python_function_axhline
Definition matplotlibcpp.h:78
matplotlibcpp::detail::_interpreter::s_python_function_clf
PyObject * s_python_function_clf
Definition matplotlibcpp.h:90
matplotlibcpp::detail::_interpreter::s_python_function_xlim
PyObject * s_python_function_xlim
Definition matplotlibcpp.h:72
matplotlibcpp::detail::_interpreter::s_python_function_errorbar
PyObject * s_python_function_errorbar
Definition matplotlibcpp.h:91
matplotlibcpp::detail::_interpreter::s_python_function_axvline
PyObject * s_python_function_axvline
Definition matplotlibcpp.h:79
matplotlibcpp::detail::_interpreter::s_python_function_arrow
PyObject * s_python_function_arrow
Definition matplotlibcpp.h:49
matplotlibcpp::detail::_interpreter::s_python_function_subplot2grid
PyObject * s_python_function_subplot2grid
Definition matplotlibcpp.h:70
matplotlibcpp::detail::_interpreter::s_python_function_barh
PyObject * s_python_function_barh
Definition matplotlibcpp.h:101
matplotlibcpp::detail::_interpreter::s_python_function_hist
PyObject * s_python_function_hist
Definition matplotlibcpp.h:65
matplotlibcpp::detail::_interpreter::s_python_function_suptitle
PyObject * s_python_function_suptitle
Definition matplotlibcpp.h:99
matplotlibcpp::detail::_interpreter::s_python_function_boxplot
PyObject * s_python_function_boxplot
Definition matplotlibcpp.h:68
matplotlibcpp::detail::_interpreter::s_python_function_xlabel
PyObject * s_python_function_xlabel
Definition matplotlibcpp.h:81
matplotlibcpp::detail::_interpreter::s_python_function_spy
PyObject * s_python_function_spy
Definition matplotlibcpp.h:105
matplotlibcpp::detail::_interpreter::s_python_function_legend
PyObject * s_python_function_legend
Definition matplotlibcpp.h:71
matplotlibcpp::detail::_interpreter::s_python_function_margins
PyObject * s_python_function_margins
Definition matplotlibcpp.h:86
matplotlibcpp::detail::_interpreter::s_python_function_ginput
PyObject * s_python_function_ginput
Definition matplotlibcpp.h:74
matplotlibcpp::detail::_interpreter::interkeeper
static _interpreter & interkeeper(bool should_kill)
Definition matplotlibcpp.h:128
matplotlibcpp::detail::_interpreter::s_python_function_stem
PyObject * s_python_function_stem
Definition matplotlibcpp.h:96
matplotlibcpp::detail::_interpreter::s_python_function_grid
PyObject * s_python_function_grid
Definition matplotlibcpp.h:88
matplotlibcpp::detail::_interpreter::s_python_function_semilogy
PyObject * s_python_function_semilogy
Definition matplotlibcpp.h:61
matplotlibcpp::detail::_interpreter::s_python_function_draw
PyObject * s_python_function_draw
Definition matplotlibcpp.h:52
matplotlibcpp::detail::_interpreter::s_python_function_fignum_exists
PyObject * s_python_function_fignum_exists
Definition matplotlibcpp.h:56
matplotlibcpp::detail::_interpreter::s_python_function_xticks
PyObject * s_python_function_xticks
Definition matplotlibcpp.h:84
matplotlibcpp::detail::_interpreter::s_python_function_contour
PyObject * s_python_function_contour
Definition matplotlibcpp.h:59
matplotlibcpp::detail::_interpreter::s_python_function_close
PyObject * s_python_function_close
Definition matplotlibcpp.h:51
matplotlibcpp::detail::_interpreter::get
static _interpreter & get()
Definition matplotlibcpp.h:119
matplotlibcpp::detail::_interpreter::s_python_function_axis
PyObject * s_python_function_axis
Definition matplotlibcpp.h:77
matplotlibcpp::detail::_interpreter::s_python_function_plot
PyObject * s_python_function_plot
Definition matplotlibcpp.h:57
matplotlibcpp::detail::_interpreter::s_python_function_rcparams
PyObject * s_python_function_rcparams
Definition matplotlibcpp.h:104
matplotlibcpp::detail::_interpreter::_interpreter
_interpreter()
Definition matplotlibcpp.h:166
matplotlibcpp::detail::_interpreter::s_python_function_figure
PyObject * s_python_function_figure
Definition matplotlibcpp.h:55
matplotlibcpp::detail::_interpreter::s_python_function_gca
PyObject * s_python_function_gca
Definition matplotlibcpp.h:83
matplotlibcpp::detail::_interpreter::s_python_function_axvspan
PyObject * s_python_function_axvspan
Definition matplotlibcpp.h:80
matplotlibcpp::detail::_interpreter::s_python_function_loglog
PyObject * s_python_function_loglog
Definition matplotlibcpp.h:62
matplotlibcpp::detail::_interpreter::s_python_function_tight_layout
PyObject * s_python_function_tight_layout
Definition matplotlibcpp.h:93
matplotlibcpp::detail::_interpreter::s_python_function_save
PyObject * s_python_function_save
Definition matplotlibcpp.h:54
matplotlibcpp::detail::_interpreter::s_python_function_title
PyObject * s_python_function_title
Definition matplotlibcpp.h:76
matplotlibcpp::detail::_interpreter::s_python_function_fill
PyObject * s_python_function_fill
Definition matplotlibcpp.h:63
matplotlibcpp::detail::_interpreter::s_python_function_show
PyObject * s_python_function_show
Definition matplotlibcpp.h:50
matplotlibcpp::detail::_interpreter::s_python_function_quiver
PyObject * s_python_function_quiver
Definition matplotlibcpp.h:58
matplotlibcpp::detail::_interpreter::safe_import
PyObject * safe_import(PyObject *module, std::string fname)
Definition matplotlibcpp.h:135
matplotlibcpp::detail::_interpreter::kill
static _interpreter & kill()
Definition matplotlibcpp.h:123
matplotlibcpp::detail::_interpreter::s_python_function_ylabel
PyObject * s_python_function_ylabel
Definition matplotlibcpp.h:82
matplotlibcpp::detail::_interpreter::s_python_empty_tuple
PyObject * s_python_empty_tuple
Definition matplotlibcpp.h:95
matplotlibcpp::detail::_interpreter::s_python_function_cla
PyObject * s_python_function_cla
Definition matplotlibcpp.h:89
matplotlibcpp::detail::_interpreter::~_interpreter
~_interpreter()
Definition matplotlibcpp.h:287
matplotlibcpp::detail::_interpreter::s_python_function_semilogx
PyObject * s_python_function_semilogx
Definition matplotlibcpp.h:60
matplotlibcpp::detail::_interpreter::s_python_function_colorbar
PyObject * s_python_function_colorbar
Definition matplotlibcpp.h:102
matplotlibcpp::detail::_interpreter::s_python_function_imshow
PyObject * s_python_function_imshow
Definition matplotlibcpp.h:66
matplotlibcpp::detail::_interpreter::s_python_function_bar
PyObject * s_python_function_bar
Definition matplotlibcpp.h:100
matplotlibcpp::detail::_interpreter::s_python_function_subplot
PyObject * s_python_function_subplot
Definition matplotlibcpp.h:69
matplotlibcpp::detail::_interpreter::s_python_function_xkcd
PyObject * s_python_function_xkcd
Definition matplotlibcpp.h:97
matplotlibcpp::detail::_interpreter::s_python_function_ion
PyObject * s_python_function_ion
Definition matplotlibcpp.h:73
matplotlibcpp::detail::_interpreter::import_numpy
void import_numpy()
Definition matplotlibcpp.h:159
matplotlibcpp::detail::_interpreter::s_python_colormap
PyObject * s_python_colormap
Definition matplotlibcpp.h:94
matplotlibcpp::detail::_interpreter::s_python_function_pause
PyObject * s_python_function_pause
Definition matplotlibcpp.h:53
matplotlibcpp::detail::_interpreter::s_python_function_yticks
PyObject * s_python_function_yticks
Definition matplotlibcpp.h:85
matplotlibcpp::detail::_interpreter::s_python_function_subplots_adjust
PyObject * s_python_function_subplots_adjust
Definition matplotlibcpp.h:103
matplotlibcpp::detail::_interpreter::s_python_function_scatter
PyObject * s_python_function_scatter
Definition matplotlibcpp.h:67
matplotlibcpp::detail::_interpreter::s_python_function_annotate
PyObject * s_python_function_annotate
Definition matplotlibcpp.h:92
matplotlibcpp::detail::_interpreter::s_python_function_fill_between
PyObject * s_python_function_fill_between
Definition matplotlibcpp.h:64
matplotlibcpp::detail::_interpreter::s_python_function_ylim
PyObject * s_python_function_ylim
Definition matplotlibcpp.h:75
matplotlibcpp::detail::_interpreter::s_python_function_tick_params
PyObject * s_python_function_tick_params
Definition matplotlibcpp.h:87
matplotlibcpp::detail::_interpreter::s_python_function_text
PyObject * s_python_function_text
Definition matplotlibcpp.h:98
matplotlibcpp::detail::is_callable_impl< false, T >::type
is_function< T > type
Definition matplotlibcpp.h:2766
matplotlibcpp::detail::is_callable_impl< true, T >::Check
Definition matplotlibcpp.h:2775
matplotlibcpp::detail::is_callable_impl< true, T >::Derived
Definition matplotlibcpp.h:2773
matplotlibcpp::detail::is_callable_impl< true, T >::Fallback
Definition matplotlibcpp.h:2772
matplotlibcpp::detail::is_callable_impl< true, T >::Fallback::operator()
void operator()()
matplotlibcpp::detail::is_callable_impl< true, T >::test
static std::true_type test(...)
matplotlibcpp::detail::is_callable_impl< true, T >::value
static constexpr bool value
Definition matplotlibcpp.h:2786
matplotlibcpp::detail::is_callable_impl< true, T >::type
decltype(test< Derived >(nullptr)) type
Definition matplotlibcpp.h:2784
matplotlibcpp::detail::is_callable_impl< true, T >::dtype
decltype(&Fallback::operator()) dtype
Definition matplotlibcpp.h:2785
matplotlibcpp::detail::is_callable_impl< true, T >::test
static std::false_type test(Check< void(Fallback::*)(), &U::operator()> *)
matplotlibcpp::detail::type
matplotlibcpp::detail::is_callable
Definition matplotlibcpp.h:2791
matplotlibcpp::detail::is_callable::type
is_callable_impl< std::is_class< T >::value, T >::type type
Definition matplotlibcpp.h:2793
matplotlibcpp::detail::plot_impl< std::false_type >::operator()
bool operator()(const IterableX &x, const IterableY &y, const std::string &format)
Definition matplotlibcpp.h:2803
matplotlibcpp::detail::plot_impl< std::true_type >::operator()
bool operator()(const Iterable &ticks, const Callable &f, const std::string &format)
Definition matplotlibcpp.h:2844
matplotlibcpp::detail::plot_impl
Definition matplotlibcpp.h:2797
matplotlibcpp::detail::select_npy_type< bool >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:341
matplotlibcpp::detail::select_npy_type< double >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:339
matplotlibcpp::detail::select_npy_type< float >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:340
matplotlibcpp::detail::select_npy_type< int16_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:343
matplotlibcpp::detail::select_npy_type< int32_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:344
matplotlibcpp::detail::select_npy_type< int64_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:345
matplotlibcpp::detail::select_npy_type< int8_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:342
matplotlibcpp::detail::select_npy_type< long long >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:354
matplotlibcpp::detail::select_npy_type< uint16_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:347
matplotlibcpp::detail::select_npy_type< uint32_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:348
matplotlibcpp::detail::select_npy_type< uint64_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:349
matplotlibcpp::detail::select_npy_type< uint8_t >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:346
matplotlibcpp::detail::select_npy_type< unsigned long long >::type
static const NPY_TYPES type
Definition matplotlibcpp.h:356
matplotlibcpp::detail::select_npy_type
Definition matplotlibcpp.h:338
matplotlibcpp::detail::select_npy_type::type
static const NPY_TYPES type
Definition matplotlibcpp.h:338