diff --git a/src/icp.h b/src/icp.h
index 8b1a39fd3424ce20b91080f3a99ce6bb1217783b..9a8fb5b539d8114354e370055baf964bbfaad957 100644
--- a/src/icp.h
+++ b/src/icp.h
@@ -156,13 +156,13 @@ struct icpParams
const icpParams icp_params_default = {
false, //bool verbose; // prints debug messages
- true, 180.0, 10, // bool use_point_to_line_distance; double max_angular_correction_deg; double max_linear_correction;
- 0.5, true, false, // double max_correspondence_dist; bool use_corr_tricks; bool debug_verify_tricks;
+ true, 5.0, 1, // bool use_point_to_line_distance; double max_angular_correction_deg; double max_linear_correction;
+ 0.5, false, false, // double max_correspondence_dist; bool use_corr_tricks; bool debug_verify_tricks;
50, 1e-4, 1e-3, // int max_iterations; double epsilon_xy; double epsilon_theta;
false, 0, 0, 0, // bool restart; double restart_threshold_mean_error; double restart_dt; double restart_dtheta;
0.023, 60, // double min_reading, max_reading;
- 0.9, 0.7, 1.5, false, // double outliers_maxPerc; double outliers_adaptive_order; double outliers_adaptive_mult;
- false, false, 10, // bool outliers_remove_doubles; bool do_visibility_test; bool do_alpha_test; double do_alpha_test_thresholdDeg;
+ 1, 0.8, 2, // double outliers_maxPerc; double outliers_adaptive_order; double outliers_adaptive_mult;
+ false, false, false, 10, // bool outliers_remove_doubles; bool do_visibility_test; bool do_alpha_test; double do_alpha_test_thresholdDeg;
0.5, 4, // double clustering_threshold; int orientation_neighbourhood;
false, false, 0.2, // bool use_ml_weights; bool use_sigma_weights; double sigma;
true, 5 // bool do_compute_covariance; double cov_factor;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 44067523264e565cd26bae7e3296ddb1e206fa2a..d1684ec756f4ec46b4d5e32cd2345a80b0087b1d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -8,6 +8,7 @@ include_directories(${GTEST_INCLUDE_DIRS})
INCLUDE_DIRECTORIES(../src)
INCLUDE_DIRECTORIES(/data)
FIND_PACKAGE(Eigen3 3.3 REQUIRED)
+FIND_PACKAGE(PythonLibs 3)
INCLUDE_DIRECTORIES(${EIGEN3_INCLUDE_DIRS})
############# USE THIS TEST AS AN EXAMPLE ####################
@@ -24,7 +25,7 @@ laser_scan_utils_add_gtest(gtest_example gtest_example.cpp)
# gtest icp
IF(csm_FOUND)
laser_scan_utils_add_gtest(gtest_icp gtest_icp.cpp)
- target_link_libraries(gtest_icp ${PROJECT_NAME})
+ target_link_libraries(gtest_icp ${PROJECT_NAME} ${PYTHON_LIBRARIES})
ENDIF(csm_FOUND)
IF(falkolib_FOUND)
diff --git a/test/gtest_icp.cpp b/test/gtest_icp.cpp
index d410c0b9784a2c9c1b4c725fa0c1bce57acaa182..f4a2ad22f1dbdef70761beda8c5ddf899d14f76f 100644
--- a/test/gtest_icp.cpp
+++ b/test/gtest_icp.cpp
@@ -20,10 +20,15 @@
//
//--------LICENSE_END--------
#include "gtest/utils_gtest.h"
-
#include "laser_scan.h"
#include "icp.h"
+#define TEST_PLOTS false
+#if TEST_PLOTS
+#include "matplotlibcpp.h"
+namespace plt = matplotlibcpp;
+#endif
+
using namespace laserscanutils;
const Eigen::Vector2d A = Eigen::Vector2d::Zero();
@@ -31,6 +36,9 @@ const Eigen::Vector2d B = (Eigen::Vector2d() << 0, 40).finished();
const Eigen::Vector2d C = (Eigen::Vector2d() << 30, 0).finished();
const Eigen::Vector2d CB = B-C;
double AB_ang = atan2((A-B).norm(),(A-C).norm());
+double dist_min = 2;
+int color_id=0;
+const std::vector<std::string> colors({"b","r","g","c","m","y"});
/* Synthetic scans are created from this simple scenario with three orthogonal walls:
*
@@ -67,7 +75,7 @@ double pi2pi(const double& _angle)
bool insideTriangle(const Eigen::Vector3d& laser_pose)
{
- return laser_pose(0) > 0 and laser_pose(1) > 0 and laser_pose(0) / C(0) + laser_pose(1) / B(1) < 1;
+ return laser_pose(0) > 0 + dist_min and laser_pose(1) > 0 + dist_min and laser_pose(0) / (C(0)-dist_min/sin(AB_ang)) + laser_pose(1) / (B(1)-dist_min/cos(AB_ang)) < 1;
}
Eigen::Vector3d generateRandomPoseInsideTriangle()
@@ -79,10 +87,7 @@ Eigen::Vector3d generateRandomPoseInsideTriangle()
pose(2) *= M_PI;
if (not insideTriangle(pose))
- {
- pose(0) = C(0) - pose(0);
- pose(1) = B(1) - pose(1);
- }
+ pose = generateRandomPoseInsideTriangle();
return pose;
}
@@ -135,6 +140,9 @@ LaserScan simulateScan(const Eigen::Vector3d& laser_pose, const LaserScanParams&
else
throw std::runtime_error("bad theta angle..!");
+ // assert dist min
+ assert(scan.ranges_raw_[i] >= dist_min);
+
// max range
if (scan.ranges_raw_[i] > params.range_max_ or scan.ranges_raw_[i] < params.range_min_)
{
@@ -160,16 +168,21 @@ void generateRandomProblem(Eigen::Vector3d& pose_ref,
Eigen::Vector3d& pose_d,
const LaserScanParams& scan_params,
LaserScan& scan_ref,
- LaserScan& scan_tar)
+ LaserScan& scan_tar,
+ double perturbation = 1)
{
pose_ref = generateRandomPoseInsideTriangle();
- pose_d = Eigen::Vector3d::Random() * 0.1;
- pose_tar.head<2>() = pose_ref.head<2>() + Eigen::Rotation2Dd(pose_d(2)) * pose_d.head<2>();
+ pose_d = Eigen::Vector3d::Random() * perturbation;
+ while (pose_d(2) > M_PI)
+ pose_d(2) -= 2*M_PI;
+ while (pose_d(2) <= -M_PI)
+ pose_d(2) += 2*M_PI;
+ pose_tar.head<2>() = pose_ref.head<2>() + Eigen::Rotation2Dd(pose_ref(2)) * pose_d.head<2>();
pose_tar(2) = pose_ref(2) + pose_d(2);
while (not insideTriangle(pose_tar))
{
- pose_d = Eigen::Vector3d::Random() * 0.1;
- pose_tar.head<2>() = pose_ref.head<2>() + Eigen::Rotation2Dd(pose_d(2)) * pose_d.head<2>();
+ pose_d = Eigen::Vector3d::Random();
+ pose_tar.head<2>() = pose_ref.head<2>() + Eigen::Rotation2Dd(pose_ref(2)) * pose_d.head<2>();
pose_tar(2) = pose_ref(2) + pose_d(2);
}
@@ -177,19 +190,77 @@ void generateRandomProblem(Eigen::Vector3d& pose_ref,
scan_tar = simulateScan(pose_tar, scan_params);
}
-TEST(TestIcp, TestSimulateScan)
+LaserScanParams generateLaserScanParams(double angle_min_deg, double angle_step_deg)
{
- // 4 beams: 0º, 90º, 180ª, 270ª
+ // 360º field of view
LaserScanParams scan_params;
- scan_params.angle_min_ = 0;
- scan_params.angle_step_ = M_PI / 2;
- scan_params.angle_max_ = 3*M_PI/2;
+ scan_params.angle_min_ = angle_min_deg * M_PI / 180;
+ scan_params.angle_step_ = angle_step_deg * M_PI / 180;
+ auto n_ranges = int (2*M_PI / scan_params.angle_step_);
+ scan_params.angle_max_ = scan_params.angle_min_ + (n_ranges-1) * scan_params.angle_step_;
scan_params.scan_time_ = 0;
scan_params.range_min_ = 0;
- scan_params.range_max_ = 1e3;
+ scan_params.range_max_ = 1e2;
scan_params.range_std_dev_ = 0;
scan_params.angle_std_dev_ = 0;
+ //scan_params.print();
+ return scan_params;
+}
+
+void initPlot()
+{
+#if TEST_PLOTS
+ plt::figure();
+#endif
+}
+
+void showPlot()
+{
+#if TEST_PLOTS
+ plt::show();
+#endif
+}
+
+void plotScan(const LaserScan& scan, const LaserScanParams& scan_params, const Eigen::Vector3d pose, bool fig_created = false)
+{
+#if TEST_PLOTS
+ // Create figure
+ if (not fig_created)
+ plt::figure();
+ plt::axis("scaled");
+
+ std::vector<double> x(scan.ranges_raw_.size());
+ std::vector<double> y(scan.ranges_raw_.size());
+ for (auto i = 0; i < scan.ranges_raw_.size(); i++)
+ {
+ x.at(i) = pose(0) + cos(scan_params.angle_min_ + i*scan_params.angle_step_ + pose(2)) * scan.ranges_raw_.at(i);
+ y.at(i) = pose(1) + sin(scan_params.angle_min_ + i*scan_params.angle_step_ + pose(2)) * scan.ranges_raw_.at(i);
+ }
+ plt::plot(x, y,"."+colors.at(color_id));
+
+ std::vector<double> pose_x{pose(0)-sin(pose(2)), pose(0), pose(0)+cos(pose(2))};
+ std::vector<double> pose_y{pose(1)+cos(pose(2)), pose(1), pose(1)+sin(pose(2))};
+ plt::plot(pose_x, pose_y,colors.at(color_id)+"-");
+
+ if (not fig_created)
+ plt::show();
+
+ color_id++;
+ if (color_id >= colors.size())
+ color_id = 0;
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////// TESTS ////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+TEST(TestIcp, TestSimulateScan)
+{
+ // 4 beams: 0º, 90º, 180ª, 270ª
+ LaserScanParams scan_params = generateLaserScanParams(0,90);
+
Eigen::Vector3d laser_pose;
laser_pose << C(0) / 4, B(1) / 4, 0;
@@ -237,38 +308,118 @@ TEST(TestIcp, TestSimulateScan)
TEST(TestIcp, TestGenerateRandomPose)
{
// 0-2M_PI (5 degrees step)
- LaserScanParams scan_params;
- scan_params.angle_min_ = 0;
- scan_params.angle_step_ = 5 * M_PI / 180;
- scan_params.angle_max_ = 2*M_PI-scan_params.angle_step_;
- scan_params.scan_time_ = 0;
- scan_params.range_min_ = 0;
- scan_params.range_max_ = 1e3;
- scan_params.range_std_dev_ = 0;
- scan_params.angle_std_dev_ = 0;
+ LaserScanParams scan_params = generateLaserScanParams(-180,1);
+
+ initPlot();
+ // 100 random poses and scans
for (auto i=0; i < 100; i++)
{
auto laser_pose = generateRandomPoseInsideTriangle();
ASSERT_TRUE(insideTriangle(laser_pose));
auto scan = simulateScan(laser_pose, scan_params);
+
+ plotScan(scan, scan_params, laser_pose, true);
+ }
+
+ showPlot();
+}
+
+TEST(TestIcp, TestIcpSame1)
+{
+ // -180,180 (1 degrees step)
+ LaserScanParams scan_params = generateLaserScanParams(-180,1);
+
+ for (auto i = 0; i<10; i++)
+ {
+ auto pose = generateRandomPoseInsideTriangle();
+ auto scan = simulateScan(pose, scan_params);
+
+ // icp
+ auto icp_params = icp_params_default;
+
+ // no perturbation
+ std::cout << "//////////// TestIcpSame1: random problem " << i << " pose: " << pose.transpose() << std::endl;
+ std::cout << "//////////// NO perturbation" << std::endl;
+ auto icp_output = ICP::align(scan,
+ scan,
+ scan_params,
+ icp_params,
+ Eigen::Vector3d::Zero());
+
+ ASSERT_TRUE(icp_output.valid);
+ EXPECT_MATRIX_APPROX(icp_output.res_transf, Eigen::Vector3d::Zero(), 1e-1);
+
+ // perturbation
+ std::cout << "//////////// WITH perturbation" << std::endl;
+ icp_output = ICP::align(scan,
+ scan,
+ scan_params,
+ icp_params,
+ Eigen::Vector3d::Random()*0.1);
+
+ if (not icp_output.valid)
+ icp_output = ICP::align(scan,
+ scan,
+ scan_params,
+ icp_params,
+ Eigen::Vector3d::Random()*0.1);
+
+ ASSERT_TRUE(icp_output.valid);
+ EXPECT_MATRIX_APPROX(icp_output.res_transf, Eigen::Vector3d::Zero(), 1e-1);
+ }
+}
+
+TEST(TestIcp, TestIcpSame2)
+{
+ // 0,360 (1 degrees step)
+ LaserScanParams scan_params = generateLaserScanParams(0,1);
+
+ for (auto i = 0; i<10; i++)
+ {
+ auto pose = generateRandomPoseInsideTriangle();
+ auto scan = simulateScan(pose, scan_params);
+
+ // icp
+ auto icp_params = icp_params_default;
+
+ // no perturbation
+ std::cout << "//////////// TestIcpSame1: random problem " << i << " pose: " << pose.transpose() << std::endl;
+ std::cout << "//////////// NO perturbation" << std::endl;
+ auto icp_output = ICP::align(scan,
+ scan,
+ scan_params,
+ icp_params,
+ Eigen::Vector3d::Zero());
+
+ ASSERT_TRUE(icp_output.valid);
+ EXPECT_MATRIX_APPROX(icp_output.res_transf, Eigen::Vector3d::Zero(), 1e-1);
+
+ // perturbation
+ std::cout << "//////////// WITH perturbation" << std::endl;
+ icp_output = ICP::align(scan,
+ scan,
+ scan_params,
+ icp_params,
+ Eigen::Vector3d::Random()*0.1);
+
+ if (not icp_output.valid)
+ icp_output = ICP::align(scan,
+ scan,
+ scan_params,
+ icp_params,
+ Eigen::Vector3d::Random()*0.1);
+
+ ASSERT_TRUE(icp_output.valid);
+ EXPECT_MATRIX_APPROX(icp_output.res_transf, Eigen::Vector3d::Zero(), 1e-1);
}
}
TEST(TestIcp, TestIcp1)
{
- // Scan params
- // 0-2M_PI (5 degrees step)
- LaserScanParams scan_params;
- scan_params.angle_min_ = 0;
- scan_params.angle_step_ = 5 * M_PI / 180;
- scan_params.angle_max_ = 2*M_PI-scan_params.angle_step_;
- scan_params.scan_time_ = 0;
- scan_params.range_min_ = 0;
- scan_params.range_max_ = 1e2;
- scan_params.range_std_dev_ = 0;
- scan_params.angle_std_dev_ = 0;
+ // 0,360 (1 degrees step)
+ LaserScanParams scan_params = generateLaserScanParams(0,1);
Eigen::Vector3d pose_ref, pose_tar, pose_d;
LaserScan scan_ref, scan_tar;
@@ -278,12 +429,13 @@ TEST(TestIcp, TestIcp1)
// Random problem
generateRandomProblem(pose_ref, pose_tar, pose_d, scan_params, scan_ref, scan_tar);
+ std::cout << "//////////// TestIcp1: random problem " << i << std::endl;
+ std::cout << "\tpose_ref: " << pose_ref.transpose() << std::endl;
+ std::cout << "\tpose_tar: " << pose_tar.transpose() << std::endl;
+
// icp
auto icp_params = icp_params_default;
- //icp_params.max_linear_correction = 20;
- //icp_params.print();
- icp_params.verbose = true;
auto icp_output = ICP::align(scan_tar,
scan_ref,
scan_params,
@@ -293,10 +445,52 @@ TEST(TestIcp, TestIcp1)
ASSERT_TRUE(icp_output.valid);
EXPECT_MATRIX_APPROX(icp_output.res_transf, pose_d, 1e-1);
+
+ initPlot();
+ plotScan(scan_ref,scan_params,pose_ref,true);
+ plotScan(scan_tar,scan_params,pose_tar,true);
+ showPlot();
}
}
+TEST(TestIcp, TestIcp10)
+{
+ // -180,180 (1 degrees step)
+ LaserScanParams scan_params = generateLaserScanParams(-180,1);
+
+ Eigen::Vector3d pose_ref, pose_tar, pose_d;
+ LaserScan scan_ref, scan_tar;
+
+ for (auto i=0; i < 10; i++)
+ {
+ // Random problem
+ generateRandomProblem(pose_ref, pose_tar, pose_d, scan_params, scan_ref, scan_tar, 10);
+
+ std::cout << "//////////// TestIcp1: random problem " << i << std::endl;
+ std::cout << "\tpose_ref: " << pose_ref.transpose() << std::endl;
+ std::cout << "\tpose_tar: " << pose_tar.transpose() << std::endl;
+
+ // icp
+ auto icp_params = icp_params_default;
+
+ auto icp_output = ICP::align(scan_tar,
+ scan_ref,
+ scan_params,
+ icp_params,
+ pose_d);
+
+ ASSERT_TRUE(icp_output.valid);
+ EXPECT_MATRIX_APPROX(icp_output.res_transf, pose_d, 1e-1);
+
+ initPlot();
+ plotScan(scan_ref,scan_params,pose_ref,true);
+ plotScan(scan_tar,scan_params,pose_tar,true);
+ showPlot();
+ }
+}//*/
+
+
int main(int argc, char **argv)
{
testing::InitGoogleTest(&argc, argv);
diff --git a/test/matplotlibcpp.h b/test/matplotlibcpp.h
new file mode 100644
index 0000000000000000000000000000000000000000..d95d46ad41379be376401b2b761e8a1d47bfee62
--- /dev/null
+++ b/test/matplotlibcpp.h
@@ -0,0 +1,2986 @@
+#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
+
+/// Select the backend
+///
+/// **NOTE:** This must be called before the first plot command to have
+/// any effect.
+///
+/// Mainly useful to select the non-interactive 'Agg' backend when running
+/// matplotlibcpp in headless mode, for example on a machine with no display.
+///
+/// See also: https://matplotlib.org/2.0.2/api/matplotlib_configuration_api.html#matplotlib.use
+inline void backend(const std::string& name)
+{
+ detail::s_backend = name;
+}
+
+inline bool annotate(std::string annotation, double x, double y)
+{
+ detail::_interpreter::get();
+
+ PyObject * xy = PyTuple_New(2);
+ PyObject * str = PyString_FromString(annotation.c_str());
+
+ PyTuple_SetItem(xy,0,PyFloat_FromDouble(x));
+ PyTuple_SetItem(xy,1,PyFloat_FromDouble(y));
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "xy", xy);
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, str);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_annotate, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+namespace detail {
+
+#ifndef WITHOUT_NUMPY
+// Type selector for numpy array conversion
+template <typename T> struct select_npy_type { const static NPY_TYPES type = NPY_NOTYPE; }; //Default
+template <> struct select_npy_type<double> { const static NPY_TYPES type = NPY_DOUBLE; };
+template <> struct select_npy_type<float> { const static NPY_TYPES type = NPY_FLOAT; };
+template <> struct select_npy_type<bool> { const static NPY_TYPES type = NPY_BOOL; };
+template <> struct select_npy_type<int8_t> { const static NPY_TYPES type = NPY_INT8; };
+template <> struct select_npy_type<int16_t> { const static NPY_TYPES type = NPY_SHORT; };
+template <> struct select_npy_type<int32_t> { const static NPY_TYPES type = NPY_INT; };
+template <> struct select_npy_type<int64_t> { const static NPY_TYPES type = NPY_INT64; };
+template <> struct select_npy_type<uint8_t> { const static NPY_TYPES type = NPY_UINT8; };
+template <> struct select_npy_type<uint16_t> { const static NPY_TYPES type = NPY_USHORT; };
+template <> struct select_npy_type<uint32_t> { const static NPY_TYPES type = NPY_ULONG; };
+template <> struct select_npy_type<uint64_t> { const static NPY_TYPES type = NPY_UINT64; };
+
+// Sanity checks; comment them out or change the numpy type below if you're compiling on
+// a platform where they don't apply
+static_assert(sizeof(long long) == 8);
+template <> struct select_npy_type<long long> { const static NPY_TYPES type = NPY_INT64; };
+static_assert(sizeof(unsigned long long) == 8);
+template <> struct select_npy_type<unsigned long long> { const static NPY_TYPES type = NPY_UINT64; };
+
+template<typename Numeric>
+PyObject* get_array(const std::vector<Numeric>& v)
+{
+ npy_intp vsize = v.size();
+ NPY_TYPES type = select_npy_type<Numeric>::type;
+ if (type == NPY_NOTYPE) {
+ size_t memsize = v.size()*sizeof(double);
+ double* dp = static_cast<double*>(::malloc(memsize));
+ for (size_t i=0; i<v.size(); ++i)
+ dp[i] = v[i];
+ PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, NPY_DOUBLE, dp);
+ PyArray_UpdateFlags(reinterpret_cast<PyArrayObject*>(varray), NPY_ARRAY_OWNDATA);
+ return varray;
+ }
+
+ PyObject* varray = PyArray_SimpleNewFromData(1, &vsize, type, (void*)(v.data()));
+ return varray;
+}
+
+
+template<typename Numeric>
+PyObject* get_2darray(const std::vector<::std::vector<Numeric>>& v)
+{
+ if (v.size() < 1) throw std::runtime_error("get_2d_array v too small");
+
+ npy_intp vsize[2] = {static_cast<npy_intp>(v.size()),
+ static_cast<npy_intp>(v[0].size())};
+
+ PyArrayObject *varray =
+ (PyArrayObject *)PyArray_SimpleNew(2, vsize, NPY_DOUBLE);
+
+ double *vd_begin = static_cast<double *>(PyArray_DATA(varray));
+
+ for (const ::std::vector<Numeric> &v_row : v) {
+ if (v_row.size() != static_cast<size_t>(vsize[1]))
+ throw std::runtime_error("Missmatched array size");
+ std::copy(v_row.begin(), v_row.end(), vd_begin);
+ vd_begin += vsize[1];
+ }
+
+ return reinterpret_cast<PyObject *>(varray);
+}
+
+#else // fallback if we don't have numpy: copy every element of the given vector
+
+template<typename Numeric>
+PyObject* get_array(const std::vector<Numeric>& v)
+{
+ PyObject* list = PyList_New(v.size());
+ for(size_t i = 0; i < v.size(); ++i) {
+ PyList_SetItem(list, i, PyFloat_FromDouble(v.at(i)));
+ }
+ return list;
+}
+
+#endif // WITHOUT_NUMPY
+
+// sometimes, for labels and such, we need string arrays
+inline PyObject * get_array(const std::vector<std::string>& strings)
+{
+ PyObject* list = PyList_New(strings.size());
+ for (std::size_t i = 0; i < strings.size(); ++i) {
+ PyList_SetItem(list, i, PyString_FromString(strings[i].c_str()));
+ }
+ return list;
+}
+
+// not all matplotlib need 2d arrays, some prefer lists of lists
+template<typename Numeric>
+PyObject* get_listlist(const std::vector<std::vector<Numeric>>& ll)
+{
+ PyObject* listlist = PyList_New(ll.size());
+ for (std::size_t i = 0; i < ll.size(); ++i) {
+ PyList_SetItem(listlist, i, get_array(ll[i]));
+ }
+ return listlist;
+}
+
+} // namespace detail
+
+/// Plot a line through the given x and y data points..
+///
+/// See: https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.plot.html
+template<typename Numeric>
+bool plot(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ // using numpy arrays
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ // construct positional args
+ PyObject* args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+// TODO - it should be possible to make this work by implementing
+// a non-numpy alternative for `detail::get_2darray()`.
+#ifndef WITHOUT_NUMPY
+template <typename Numeric>
+void plot_surface(const std::vector<::std::vector<Numeric>> &x,
+ const std::vector<::std::vector<Numeric>> &y,
+ const std::vector<::std::vector<Numeric>> &z,
+ const std::map<std::string, std::string> &keywords =
+ std::map<std::string, std::string>(),
+ const long fig_number=0)
+{
+ detail::_interpreter::get();
+
+ // We lazily load the modules here the first time this function is called
+ // because I'm not sure that we can assume "matplotlib installed" implies
+ // "mpl_toolkits installed" on all platforms, and we don't want to require
+ // it for people who don't need 3d plots.
+ static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+ if (!mpl_toolkitsmod) {
+ detail::_interpreter::get();
+
+ PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+ PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+ if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+ mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+ Py_DECREF(mpl_toolkits);
+ if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+ axis3dmod = PyImport_Import(axis3d);
+ Py_DECREF(axis3d);
+ if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+ }
+
+ assert(x.size() == y.size());
+ assert(y.size() == z.size());
+
+ // using numpy arrays
+ PyObject *xarray = detail::get_2darray(x);
+ PyObject *yarray = detail::get_2darray(y);
+ PyObject *zarray = detail::get_2darray(z);
+
+ // construct positional args
+ PyObject *args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+ PyTuple_SetItem(args, 2, zarray);
+
+ // Build up the kw args.
+ PyObject *kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "rstride", PyInt_FromLong(1));
+ PyDict_SetItemString(kwargs, "cstride", PyInt_FromLong(1));
+
+ PyObject *python_colormap_coolwarm = PyObject_GetAttrString(
+ detail::_interpreter::get().s_python_colormap, "coolwarm");
+
+ PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);
+
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+ it != keywords.end(); ++it) {
+ if (it->first == "linewidth" || it->first == "alpha") {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyFloat_FromDouble(std::stod(it->second)));
+ } else {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+ }
+
+ PyObject *fig_args = PyTuple_New(1);
+ PyObject* fig = nullptr;
+ PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
+ PyObject *fig_exists =
+ PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
+ if (!PyObject_IsTrue(fig_exists)) {
+ fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ detail::_interpreter::get().s_python_empty_tuple);
+ } else {
+ fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ fig_args);
+ }
+ Py_DECREF(fig_exists);
+ if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+ PyObject *gca_kwargs = PyDict_New();
+ PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+ PyObject *gca = PyObject_GetAttrString(fig, "gca");
+ if (!gca) throw std::runtime_error("No gca");
+ Py_INCREF(gca);
+ PyObject *axis = PyObject_Call(
+ gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+ if (!axis) throw std::runtime_error("No axis");
+ Py_INCREF(axis);
+
+ Py_DECREF(gca);
+ Py_DECREF(gca_kwargs);
+
+ PyObject *plot_surface = PyObject_GetAttrString(axis, "plot_surface");
+ if (!plot_surface) throw std::runtime_error("No surface");
+ Py_INCREF(plot_surface);
+ PyObject *res = PyObject_Call(plot_surface, args, kwargs);
+ if (!res) throw std::runtime_error("failed surface");
+ Py_DECREF(plot_surface);
+
+ Py_DECREF(axis);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+}
+
+template <typename Numeric>
+void contour(const std::vector<::std::vector<Numeric>> &x,
+ const std::vector<::std::vector<Numeric>> &y,
+ const std::vector<::std::vector<Numeric>> &z,
+ const std::map<std::string, std::string> &keywords = {})
+{
+ detail::_interpreter::get();
+
+ // using numpy arrays
+ PyObject *xarray = detail::get_2darray(x);
+ PyObject *yarray = detail::get_2darray(y);
+ PyObject *zarray = detail::get_2darray(z);
+
+ // construct positional args
+ PyObject *args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+ PyTuple_SetItem(args, 2, zarray);
+
+ // Build up the kw args.
+ PyObject *kwargs = PyDict_New();
+
+ PyObject *python_colormap_coolwarm = PyObject_GetAttrString(
+ detail::_interpreter::get().s_python_colormap, "coolwarm");
+
+ PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);
+
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+ it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_contour, args, kwargs);
+ if (!res)
+ throw std::runtime_error("failed contour");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+}
+
+template <typename Numeric>
+void spy(const std::vector<::std::vector<Numeric>> &x,
+ const double markersize = -1, // -1 for default matplotlib size
+ const std::map<std::string, std::string> &keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject *xarray = detail::get_2darray(x);
+
+ PyObject *kwargs = PyDict_New();
+ if (markersize != -1) {
+ PyDict_SetItemString(kwargs, "markersize", PyFloat_FromDouble(markersize));
+ }
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+ it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject *plot_args = PyTuple_New(1);
+ PyTuple_SetItem(plot_args, 0, xarray);
+
+ PyObject *res = PyObject_Call(
+ detail::_interpreter::get().s_python_function_spy, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+}
+#endif // WITHOUT_NUMPY
+
+template <typename Numeric>
+void plot3(const std::vector<Numeric> &x,
+ const std::vector<Numeric> &y,
+ const std::vector<Numeric> &z,
+ const std::map<std::string, std::string> &keywords =
+ std::map<std::string, std::string>(),
+ const long fig_number=0)
+{
+ detail::_interpreter::get();
+
+ // Same as with plot_surface: We lazily load the modules here the first time
+ // this function is called because I'm not sure that we can assume "matplotlib
+ // installed" implies "mpl_toolkits installed" on all platforms, and we don't
+ // want to require it for people who don't need 3d plots.
+ static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+ if (!mpl_toolkitsmod) {
+ detail::_interpreter::get();
+
+ PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+ PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+ if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+ mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+ Py_DECREF(mpl_toolkits);
+ if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+ axis3dmod = PyImport_Import(axis3d);
+ Py_DECREF(axis3d);
+ if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+ }
+
+ assert(x.size() == y.size());
+ assert(y.size() == z.size());
+
+ PyObject *xarray = detail::get_array(x);
+ PyObject *yarray = detail::get_array(y);
+ PyObject *zarray = detail::get_array(z);
+
+ // construct positional args
+ PyObject *args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+ PyTuple_SetItem(args, 2, zarray);
+
+ // Build up the kw args.
+ PyObject *kwargs = PyDict_New();
+
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+ it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject *fig_args = PyTuple_New(1);
+ PyObject* fig = nullptr;
+ PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
+ PyObject *fig_exists =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
+ if (!PyObject_IsTrue(fig_exists)) {
+ fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ detail::_interpreter::get().s_python_empty_tuple);
+ } else {
+ fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ fig_args);
+ }
+ if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+ PyObject *gca_kwargs = PyDict_New();
+ PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+ PyObject *gca = PyObject_GetAttrString(fig, "gca");
+ if (!gca) throw std::runtime_error("No gca");
+ Py_INCREF(gca);
+ PyObject *axis = PyObject_Call(
+ gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+ if (!axis) throw std::runtime_error("No axis");
+ Py_INCREF(axis);
+
+ Py_DECREF(gca);
+ Py_DECREF(gca_kwargs);
+
+ PyObject *plot3 = PyObject_GetAttrString(axis, "plot");
+ if (!plot3) throw std::runtime_error("No 3D line plot");
+ Py_INCREF(plot3);
+ PyObject *res = PyObject_Call(plot3, args, kwargs);
+ if (!res) throw std::runtime_error("Failed 3D line plot");
+ Py_DECREF(plot3);
+
+ Py_DECREF(axis);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+}
+
+template<typename Numeric>
+bool stem(const std::vector<Numeric> &x, const std::vector<Numeric> &y, const std::map<std::string, std::string>& keywords)
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ // using numpy arrays
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ // construct positional args
+ PyObject* args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for (std::map<std::string, std::string>::const_iterator it =
+ keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(
+ detail::_interpreter::get().s_python_function_stem, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (res)
+ Py_DECREF(res);
+
+ return res;
+}
+
+template< typename Numeric >
+bool fill(const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::map<std::string, std::string>& keywords)
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ // using numpy arrays
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ // construct positional args
+ PyObject* args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template< typename Numeric >
+bool fill_between(const std::vector<Numeric>& x, const std::vector<Numeric>& y1, const std::vector<Numeric>& y2, const std::map<std::string, std::string>& keywords)
+{
+ assert(x.size() == y1.size());
+ assert(x.size() == y2.size());
+
+ detail::_interpreter::get();
+
+ // using numpy arrays
+ PyObject* xarray = detail::get_array(x);
+ PyObject* y1array = detail::get_array(y1);
+ PyObject* y2array = detail::get_array(y2);
+
+ // construct positional args
+ PyObject* args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, y1array);
+ PyTuple_SetItem(args, 2, y2array);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_fill_between, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template <typename Numeric>
+bool arrow(Numeric x, Numeric y, Numeric end_x, Numeric end_y, const std::string& fc = "r",
+ const std::string ec = "k", Numeric head_length = 0.25, Numeric head_width = 0.1625) {
+ PyObject* obj_x = PyFloat_FromDouble(x);
+ PyObject* obj_y = PyFloat_FromDouble(y);
+ PyObject* obj_end_x = PyFloat_FromDouble(end_x);
+ PyObject* obj_end_y = PyFloat_FromDouble(end_y);
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "fc", PyString_FromString(fc.c_str()));
+ PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+ PyDict_SetItemString(kwargs, "head_width", PyFloat_FromDouble(head_width));
+ PyDict_SetItemString(kwargs, "head_length", PyFloat_FromDouble(head_length));
+
+ PyObject* plot_args = PyTuple_New(4);
+ PyTuple_SetItem(plot_args, 0, obj_x);
+ PyTuple_SetItem(plot_args, 1, obj_y);
+ PyTuple_SetItem(plot_args, 2, obj_end_x);
+ PyTuple_SetItem(plot_args, 3, obj_end_y);
+
+ PyObject* res =
+ PyObject_Call(detail::_interpreter::get().s_python_function_arrow, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if (res)
+ Py_DECREF(res);
+
+ return res;
+}
+
+template< typename Numeric>
+bool hist(const std::vector<Numeric>& y, long bins=10,std::string color="b",
+ double alpha=1.0, bool cumulative=false)
+{
+ detail::_interpreter::get();
+
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
+ PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
+ PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+ PyDict_SetItemString(kwargs, "cumulative", cumulative ? Py_True : Py_False);
+
+ PyObject* plot_args = PyTuple_New(1);
+
+ PyTuple_SetItem(plot_args, 0, yarray);
+
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+#ifndef WITHOUT_NUMPY
+namespace detail {
+
+inline void imshow(void *ptr, const NPY_TYPES type, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords, PyObject** out)
+{
+ assert(type == NPY_UINT8 || type == NPY_FLOAT);
+ assert(colors == 1 || colors == 3 || colors == 4);
+
+ detail::_interpreter::get();
+
+ // construct args
+ npy_intp dims[3] = { rows, columns, colors };
+ PyObject *args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyArray_SimpleNewFromData(colors == 1 ? 2 : 3, dims, type, ptr));
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_imshow, args, kwargs);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (!res)
+ throw std::runtime_error("Call to imshow() failed");
+ if (out)
+ *out = res;
+ else
+ Py_DECREF(res);
+}
+
+} // namespace detail
+
+inline void imshow(const unsigned char *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject** out = nullptr)
+{
+ detail::imshow((void *) ptr, NPY_UINT8, rows, columns, colors, keywords, out);
+}
+
+inline void imshow(const float *ptr, const int rows, const int columns, const int colors, const std::map<std::string, std::string> &keywords = {}, PyObject** out = nullptr)
+{
+ detail::imshow((void *) ptr, NPY_FLOAT, rows, columns, colors, keywords, out);
+}
+
+#ifdef WITH_OPENCV
+void imshow(const cv::Mat &image, const std::map<std::string, std::string> &keywords = {})
+{
+ // Convert underlying type of matrix, if needed
+ cv::Mat image2;
+ NPY_TYPES npy_type = NPY_UINT8;
+ switch (image.type() & CV_MAT_DEPTH_MASK) {
+ case CV_8U:
+ image2 = image;
+ break;
+ case CV_32F:
+ image2 = image;
+ npy_type = NPY_FLOAT;
+ break;
+ default:
+ image.convertTo(image2, CV_MAKETYPE(CV_8U, image.channels()));
+ }
+
+ // If color image, convert from BGR to RGB
+ switch (image2.channels()) {
+ case 3:
+ cv::cvtColor(image2, image2, CV_BGR2RGB);
+ break;
+ case 4:
+ cv::cvtColor(image2, image2, CV_BGRA2RGBA);
+ }
+
+ detail::imshow(image2.data, npy_type, image2.rows, image2.cols, image2.channels(), keywords);
+}
+#endif // WITH_OPENCV
+#endif // WITHOUT_NUMPY
+
+template<typename NumericX, typename NumericY>
+bool scatter(const std::vector<NumericX>& x,
+ const std::vector<NumericY>& y,
+ const double s=1.0, // The marker size in points**2
+ const std::map<std::string, std::string> & keywords = {})
+{
+ detail::_interpreter::get();
+
+ assert(x.size() == y.size());
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
+ for (const auto& it : keywords)
+ {
+ PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+ }
+
+ PyObject* plot_args = PyTuple_New(2);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY, typename NumericColors>
+ bool scatter_colored(const std::vector<NumericX>& x,
+ const std::vector<NumericY>& y,
+ const std::vector<NumericColors>& colors,
+ const double s=1.0, // The marker size in points**2
+ const std::map<std::string, std::string> & keywords = {})
+ {
+ detail::_interpreter::get();
+
+ assert(x.size() == y.size());
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+ PyObject* colors_array = detail::get_array(colors);
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "s", PyLong_FromLong(s));
+ PyDict_SetItemString(kwargs, "c", colors_array);
+
+ for (const auto& it : keywords)
+ {
+ PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+ }
+
+ PyObject* plot_args = PyTuple_New(2);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+ }
+
+
+template<typename NumericX, typename NumericY, typename NumericZ>
+bool scatter(const std::vector<NumericX>& x,
+ const std::vector<NumericY>& y,
+ const std::vector<NumericZ>& z,
+ const double s=1.0, // The marker size in points**2
+ const std::map<std::string, std::string> & keywords = {},
+ const long fig_number=0) {
+ detail::_interpreter::get();
+
+ // Same as with plot_surface: We lazily load the modules here the first time
+ // this function is called because I'm not sure that we can assume "matplotlib
+ // installed" implies "mpl_toolkits installed" on all platforms, and we don't
+ // want to require it for people who don't need 3d plots.
+ static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+ if (!mpl_toolkitsmod) {
+ detail::_interpreter::get();
+
+ PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+ PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+ if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+ mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+ Py_DECREF(mpl_toolkits);
+ if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+ axis3dmod = PyImport_Import(axis3d);
+ Py_DECREF(axis3d);
+ if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+ }
+
+ assert(x.size() == y.size());
+ assert(y.size() == z.size());
+
+ PyObject *xarray = detail::get_array(x);
+ PyObject *yarray = detail::get_array(y);
+ PyObject *zarray = detail::get_array(z);
+
+ // construct positional args
+ PyObject *args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, xarray);
+ PyTuple_SetItem(args, 1, yarray);
+ PyTuple_SetItem(args, 2, zarray);
+
+ // Build up the kw args.
+ PyObject *kwargs = PyDict_New();
+
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+ it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+ PyObject *fig_args = PyTuple_New(1);
+ PyObject* fig = nullptr;
+ PyTuple_SetItem(fig_args, 0, PyLong_FromLong(fig_number));
+ PyObject *fig_exists =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, fig_args);
+ if (!PyObject_IsTrue(fig_exists)) {
+ fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ detail::_interpreter::get().s_python_empty_tuple);
+ } else {
+ fig = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ fig_args);
+ }
+ Py_DECREF(fig_exists);
+ if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+ PyObject *gca_kwargs = PyDict_New();
+ PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+ PyObject *gca = PyObject_GetAttrString(fig, "gca");
+ if (!gca) throw std::runtime_error("No gca");
+ Py_INCREF(gca);
+ PyObject *axis = PyObject_Call(
+ gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+ if (!axis) throw std::runtime_error("No axis");
+ Py_INCREF(axis);
+
+ Py_DECREF(gca);
+ Py_DECREF(gca_kwargs);
+
+ PyObject *plot3 = PyObject_GetAttrString(axis, "scatter");
+ if (!plot3) throw std::runtime_error("No 3D line plot");
+ Py_INCREF(plot3);
+ PyObject *res = PyObject_Call(plot3, args, kwargs);
+ if (!res) throw std::runtime_error("Failed 3D line plot");
+ Py_DECREF(plot3);
+
+ Py_DECREF(axis);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(fig);
+ if (res) Py_DECREF(res);
+ return res;
+
+}
+
+template<typename Numeric>
+bool boxplot(const std::vector<std::vector<Numeric>>& data,
+ const std::vector<std::string>& labels = {},
+ const std::map<std::string, std::string> & keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* listlist = detail::get_listlist(data);
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, listlist);
+
+ PyObject* kwargs = PyDict_New();
+
+ // kwargs needs the labels, if there are (the correct number of) labels
+ if (!labels.empty() && labels.size() == data.size()) {
+ PyDict_SetItemString(kwargs, "labels", detail::get_array(labels));
+ }
+
+ // take care of the remaining keywords
+ for (const auto& it : keywords)
+ {
+ PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_boxplot, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename Numeric>
+bool boxplot(const std::vector<Numeric>& data,
+ const std::map<std::string, std::string> & keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* vector = detail::get_array(data);
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, vector);
+
+ PyObject* kwargs = PyDict_New();
+ for (const auto& it : keywords)
+ {
+ PyDict_SetItemString(kwargs, it.first.c_str(), PyString_FromString(it.second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_boxplot, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template <typename Numeric>
+bool bar(const std::vector<Numeric> & x,
+ const std::vector<Numeric> & y,
+ std::string ec = "black",
+ std::string ls = "-",
+ double lw = 1.0,
+ const std::map<std::string, std::string> & keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject * xarray = detail::get_array(x);
+ PyObject * yarray = detail::get_array(y);
+
+ PyObject * kwargs = PyDict_New();
+
+ PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+ PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
+ PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));
+
+ for (std::map<std::string, std::string>::const_iterator it =
+ keywords.begin();
+ it != keywords.end();
+ ++it) {
+ PyDict_SetItemString(
+ kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject * plot_args = PyTuple_New(2);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+
+ PyObject * res = PyObject_Call(
+ detail::_interpreter::get().s_python_function_bar, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template <typename Numeric>
+bool bar(const std::vector<Numeric> & y,
+ std::string ec = "black",
+ std::string ls = "-",
+ double lw = 1.0,
+ const std::map<std::string, std::string> & keywords = {})
+{
+ using T = typename std::remove_reference<decltype(y)>::type::value_type;
+
+ detail::_interpreter::get();
+
+ std::vector<T> x;
+ for (std::size_t i = 0; i < y.size(); i++) { x.push_back(i); }
+
+ return bar(x, y, ec, ls, lw, keywords);
+}
+
+
+template<typename Numeric>
+bool barh(const std::vector<Numeric> &x, const std::vector<Numeric> &y, std::string ec = "black", std::string ls = "-", double lw = 1.0, const std::map<std::string, std::string> &keywords = { }) {
+ PyObject *xarray = detail::get_array(x);
+ PyObject *yarray = detail::get_array(y);
+
+ PyObject *kwargs = PyDict_New();
+
+ PyDict_SetItemString(kwargs, "ec", PyString_FromString(ec.c_str()));
+ PyDict_SetItemString(kwargs, "ls", PyString_FromString(ls.c_str()));
+ PyDict_SetItemString(kwargs, "lw", PyFloat_FromDouble(lw));
+
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject *plot_args = PyTuple_New(2);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+
+ PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_barh, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+
+inline bool subplots_adjust(const std::map<std::string, double>& keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* kwargs = PyDict_New();
+ for (std::map<std::string, double>::const_iterator it =
+ keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyFloat_FromDouble(it->second));
+ }
+
+
+ PyObject* plot_args = PyTuple_New(0);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_subplots_adjust, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template< typename Numeric>
+bool named_hist(std::string label,const std::vector<Numeric>& y, long bins=10, std::string color="b", double alpha=1.0)
+{
+ detail::_interpreter::get();
+
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "label", PyString_FromString(label.c_str()));
+ PyDict_SetItemString(kwargs, "bins", PyLong_FromLong(bins));
+ PyDict_SetItemString(kwargs, "color", PyString_FromString(color.c_str()));
+ PyDict_SetItemString(kwargs, "alpha", PyFloat_FromDouble(alpha));
+
+
+ PyObject* plot_args = PyTuple_New(1);
+ PyTuple_SetItem(plot_args, 0, yarray);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_hist, plot_args, kwargs);
+
+ Py_DECREF(plot_args);
+ Py_DECREF(kwargs);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool plot(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(s.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_plot, plot_args);
+
+ Py_DECREF(plot_args);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template <typename NumericX, typename NumericY, typename NumericZ>
+bool contour(const std::vector<NumericX>& x, const std::vector<NumericY>& y,
+ const std::vector<NumericZ>& z,
+ const std::map<std::string, std::string>& keywords = {}) {
+ assert(x.size() == y.size() && x.size() == z.size());
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+ PyObject* zarray = detail::get_array(z);
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, zarray);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
+ it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res =
+ PyObject_Call(detail::_interpreter::get().s_python_function_contour, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res)
+ Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY, typename NumericU, typename NumericW>
+bool quiver(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::vector<NumericU>& u, const std::vector<NumericW>& w, const std::map<std::string, std::string>& keywords = {})
+{
+ assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+ PyObject* uarray = detail::get_array(u);
+ PyObject* warray = detail::get_array(w);
+
+ PyObject* plot_args = PyTuple_New(4);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, uarray);
+ PyTuple_SetItem(plot_args, 3, warray);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(
+ detail::_interpreter::get().s_python_function_quiver, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res)
+ Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY, typename NumericZ, typename NumericU, typename NumericW, typename NumericV>
+bool quiver(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::vector<NumericZ>& z, const std::vector<NumericU>& u, const std::vector<NumericW>& w, const std::vector<NumericV>& v, const std::map<std::string, std::string>& keywords = {})
+{
+ //set up 3d axes stuff
+ static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+ if (!mpl_toolkitsmod) {
+ detail::_interpreter::get();
+
+ PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+ PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+ if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+ mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+ Py_DECREF(mpl_toolkits);
+ if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+ axis3dmod = PyImport_Import(axis3d);
+ Py_DECREF(axis3d);
+ if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+ }
+
+ //assert sizes match up
+ assert(x.size() == y.size() && x.size() == u.size() && u.size() == w.size() && x.size() == z.size() && x.size() == v.size() && u.size() == v.size());
+
+ //set up parameters
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+ PyObject* zarray = detail::get_array(z);
+ PyObject* uarray = detail::get_array(u);
+ PyObject* warray = detail::get_array(w);
+ PyObject* varray = detail::get_array(v);
+
+ PyObject* plot_args = PyTuple_New(6);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, zarray);
+ PyTuple_SetItem(plot_args, 3, uarray);
+ PyTuple_SetItem(plot_args, 4, warray);
+ PyTuple_SetItem(plot_args, 5, varray);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ //get figure gca to enable 3d projection
+ PyObject *fig =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
+ detail::_interpreter::get().s_python_empty_tuple);
+ if (!fig) throw std::runtime_error("Call to figure() failed.");
+
+ PyObject *gca_kwargs = PyDict_New();
+ PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
+
+ PyObject *gca = PyObject_GetAttrString(fig, "gca");
+ if (!gca) throw std::runtime_error("No gca");
+ Py_INCREF(gca);
+ PyObject *axis = PyObject_Call(
+ gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
+
+ if (!axis) throw std::runtime_error("No axis");
+ Py_INCREF(axis);
+ Py_DECREF(gca);
+ Py_DECREF(gca_kwargs);
+
+ //plot our boys bravely, plot them strongly, plot them with a wink and clap
+ PyObject *plot3 = PyObject_GetAttrString(axis, "quiver");
+ if (!plot3) throw std::runtime_error("No 3D line plot");
+ Py_INCREF(plot3);
+ PyObject* res = PyObject_Call(
+ plot3, plot_args, kwargs);
+ if (!res) throw std::runtime_error("Failed 3D plot");
+ Py_DECREF(plot3);
+ Py_DECREF(axis);
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res)
+ Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool stem(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(s.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_stem, plot_args);
+
+ Py_DECREF(plot_args);
+ if (res)
+ Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool semilogx(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(s.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogx, plot_args);
+
+ Py_DECREF(plot_args);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool semilogy(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(s.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_semilogy, plot_args);
+
+ Py_DECREF(plot_args);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool loglog(const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& s = "")
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(s.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_loglog, plot_args);
+
+ Py_DECREF(plot_args);
+ if(res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool errorbar(const std::vector<NumericX> &x, const std::vector<NumericY> &y, const std::vector<NumericX> &yerr, const std::map<std::string, std::string> &keywords = {})
+{
+ assert(x.size() == y.size());
+
+ detail::_interpreter::get();
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+ PyObject* yerrarray = detail::get_array(yerr);
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyDict_SetItemString(kwargs, "yerr", yerrarray);
+
+ PyObject *plot_args = PyTuple_New(2);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+
+ PyObject *res = PyObject_Call(detail::_interpreter::get().s_python_function_errorbar, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+
+ if (res)
+ Py_DECREF(res);
+ else
+ throw std::runtime_error("Call to errorbar() failed.");
+
+ return res;
+}
+
+template<typename Numeric>
+bool named_plot(const std::string& name, const std::vector<Numeric>& y, const std::string& format = "")
+{
+ detail::_interpreter::get();
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(format.c_str());
+
+ PyObject* plot_args = PyTuple_New(2);
+
+ PyTuple_SetItem(plot_args, 0, yarray);
+ PyTuple_SetItem(plot_args, 1, pystring);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_plot(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+ detail::_interpreter::get();
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(format.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_plot, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_semilogx(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+ detail::_interpreter::get();
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(format.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogx, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_semilogy(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+ detail::_interpreter::get();
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(format.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_semilogy, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename NumericX, typename NumericY>
+bool named_loglog(const std::string& name, const std::vector<NumericX>& x, const std::vector<NumericY>& y, const std::string& format = "")
+{
+ detail::_interpreter::get();
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "label", PyString_FromString(name.c_str()));
+
+ PyObject* xarray = detail::get_array(x);
+ PyObject* yarray = detail::get_array(y);
+
+ PyObject* pystring = PyString_FromString(format.c_str());
+
+ PyObject* plot_args = PyTuple_New(3);
+ PyTuple_SetItem(plot_args, 0, xarray);
+ PyTuple_SetItem(plot_args, 1, yarray);
+ PyTuple_SetItem(plot_args, 2, pystring);
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_loglog, plot_args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(plot_args);
+ if (res) Py_DECREF(res);
+
+ return res;
+}
+
+template<typename Numeric>
+bool plot(const std::vector<Numeric>& y, const std::string& format = "")
+{
+ std::vector<Numeric> x(y.size());
+ for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
+ return plot(x,y,format);
+}
+
+template<typename Numeric>
+bool plot(const std::vector<Numeric>& y, const std::map<std::string, std::string>& keywords)
+{
+ std::vector<Numeric> x(y.size());
+ for(size_t i=0; i<x.size(); ++i) x.at(i) = i;
+ return plot(x,y,keywords);
+}
+
+template<typename Numeric>
+bool stem(const std::vector<Numeric>& y, const std::string& format = "")
+{
+ std::vector<Numeric> x(y.size());
+ for (size_t i = 0; i < x.size(); ++i) x.at(i) = i;
+ return stem(x, y, format);
+}
+
+template<typename Numeric>
+void text(Numeric x, Numeric y, const std::string& s = "")
+{
+ detail::_interpreter::get();
+
+ PyObject* args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
+ PyTuple_SetItem(args, 1, PyFloat_FromDouble(y));
+ PyTuple_SetItem(args, 2, PyString_FromString(s.c_str()));
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_text, args);
+ if(!res) throw std::runtime_error("Call to text() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+inline void colorbar(PyObject* mappable = NULL, const std::map<std::string, float>& keywords = {})
+{
+ if (mappable == NULL)
+ throw std::runtime_error("Must call colorbar with PyObject* returned from an image, contour, surface, etc.");
+
+ detail::_interpreter::get();
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, mappable);
+
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, float>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyFloat_FromDouble(it->second));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_colorbar, args, kwargs);
+ if(!res) throw std::runtime_error("Call to colorbar() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+
+inline long figure(long number = -1)
+{
+ detail::_interpreter::get();
+
+ PyObject *res;
+ if (number == -1)
+ res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, detail::_interpreter::get().s_python_empty_tuple);
+ else {
+ assert(number > 0);
+
+ // Make sure interpreter is initialised
+ detail::_interpreter::get();
+
+ PyObject *args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyLong_FromLong(number));
+ res = PyObject_CallObject(detail::_interpreter::get().s_python_function_figure, args);
+ Py_DECREF(args);
+ }
+
+ if(!res) throw std::runtime_error("Call to figure() failed.");
+
+ PyObject* num = PyObject_GetAttrString(res, "number");
+ if (!num) throw std::runtime_error("Could not get number attribute of figure object");
+ const long figureNumber = PyLong_AsLong(num);
+
+ Py_DECREF(num);
+ Py_DECREF(res);
+
+ return figureNumber;
+}
+
+inline bool fignum_exists(long number)
+{
+ detail::_interpreter::get();
+
+ PyObject *args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyLong_FromLong(number));
+ PyObject *res = PyObject_CallObject(detail::_interpreter::get().s_python_function_fignum_exists, args);
+ if(!res) throw std::runtime_error("Call to fignum_exists() failed.");
+
+ bool ret = PyObject_IsTrue(res);
+ Py_DECREF(res);
+ Py_DECREF(args);
+
+ return ret;
+}
+
+inline void figure_size(size_t w, size_t h)
+{
+ detail::_interpreter::get();
+
+ const size_t dpi = 100;
+ PyObject* size = PyTuple_New(2);
+ PyTuple_SetItem(size, 0, PyFloat_FromDouble((double)w / dpi));
+ PyTuple_SetItem(size, 1, PyFloat_FromDouble((double)h / dpi));
+
+ PyObject* kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "figsize", size);
+ PyDict_SetItemString(kwargs, "dpi", PyLong_FromSize_t(dpi));
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_figure,
+ detail::_interpreter::get().s_python_empty_tuple, kwargs);
+
+ Py_DECREF(kwargs);
+
+ if(!res) throw std::runtime_error("Call to figure_size() failed.");
+ Py_DECREF(res);
+}
+
+inline void legend()
+{
+ detail::_interpreter::get();
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple);
+ if(!res) throw std::runtime_error("Call to legend() failed.");
+
+ Py_DECREF(res);
+}
+
+inline void legend(const std::map<std::string, std::string>& keywords)
+{
+ detail::_interpreter::get();
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_legend, detail::_interpreter::get().s_python_empty_tuple, kwargs);
+ if(!res) throw std::runtime_error("Call to legend() failed.");
+
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void set_aspect(Numeric ratio)
+{
+ detail::_interpreter::get();
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(ratio));
+ PyObject* kwargs = PyDict_New();
+
+ PyObject *ax =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+ detail::_interpreter::get().s_python_empty_tuple);
+ if (!ax) throw std::runtime_error("Call to gca() failed.");
+ Py_INCREF(ax);
+
+ PyObject *set_aspect = PyObject_GetAttrString(ax, "set_aspect");
+ if (!set_aspect) throw std::runtime_error("Attribute set_aspect not found.");
+ Py_INCREF(set_aspect);
+
+ PyObject *res = PyObject_Call(set_aspect, args, kwargs);
+ if (!res) throw std::runtime_error("Call to set_aspect() failed.");
+ Py_DECREF(set_aspect);
+
+ Py_DECREF(ax);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+}
+
+inline void set_aspect_equal()
+{
+ // expect ratio == "equal". Leaving error handling to matplotlib.
+ detail::_interpreter::get();
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyString_FromString("equal"));
+ PyObject* kwargs = PyDict_New();
+
+ PyObject *ax =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+ detail::_interpreter::get().s_python_empty_tuple);
+ if (!ax) throw std::runtime_error("Call to gca() failed.");
+ Py_INCREF(ax);
+
+ PyObject *set_aspect = PyObject_GetAttrString(ax, "set_aspect");
+ if (!set_aspect) throw std::runtime_error("Attribute set_aspect not found.");
+ Py_INCREF(set_aspect);
+
+ PyObject *res = PyObject_Call(set_aspect, args, kwargs);
+ if (!res) throw std::runtime_error("Call to set_aspect() failed.");
+ Py_DECREF(set_aspect);
+
+ Py_DECREF(ax);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+}
+
+template<typename Numeric>
+void ylim(Numeric left, Numeric right)
+{
+ detail::_interpreter::get();
+
+ PyObject* list = PyList_New(2);
+ PyList_SetItem(list, 0, PyFloat_FromDouble(left));
+ PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, list);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
+ if(!res) throw std::runtime_error("Call to ylim() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+template<typename Numeric>
+void xlim(Numeric left, Numeric right)
+{
+ detail::_interpreter::get();
+
+ PyObject* list = PyList_New(2);
+ PyList_SetItem(list, 0, PyFloat_FromDouble(left));
+ PyList_SetItem(list, 1, PyFloat_FromDouble(right));
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, list);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
+ if(!res) throw std::runtime_error("Call to xlim() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+
+inline std::array<double, 2> xlim()
+{
+ PyObject* args = PyTuple_New(0);
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
+
+ if(!res) throw std::runtime_error("Call to xlim() failed.");
+
+ Py_DECREF(res);
+
+ PyObject* left = PyTuple_GetItem(res,0);
+ PyObject* right = PyTuple_GetItem(res,1);
+ return { PyFloat_AsDouble(left), PyFloat_AsDouble(right) };
+}
+
+
+inline std::array<double, 2> ylim()
+{
+ PyObject* args = PyTuple_New(0);
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
+
+ if(!res) throw std::runtime_error("Call to ylim() failed.");
+
+ Py_DECREF(res);
+
+ PyObject* left = PyTuple_GetItem(res,0);
+ PyObject* right = PyTuple_GetItem(res,1);
+ return { PyFloat_AsDouble(left), PyFloat_AsDouble(right) };
+}
+
+template<typename Numeric>
+inline void xticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string>& keywords = {})
+{
+ assert(labels.size() == 0 || ticks.size() == labels.size());
+
+ detail::_interpreter::get();
+
+ // using numpy array
+ PyObject* ticksarray = detail::get_array(ticks);
+
+ PyObject* args;
+ if(labels.size() == 0) {
+ // construct positional args
+ args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, ticksarray);
+ } else {
+ // make tuple of tick labels
+ PyObject* labelstuple = PyTuple_New(labels.size());
+ for (size_t i = 0; i < labels.size(); i++)
+ PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));
+
+ // construct positional args
+ args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, ticksarray);
+ PyTuple_SetItem(args, 1, labelstuple);
+ }
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xticks, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if(!res) throw std::runtime_error("Call to xticks() failed");
+
+ Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void xticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string>& keywords)
+{
+ xticks(ticks, {}, keywords);
+}
+
+template<typename Numeric>
+inline void yticks(const std::vector<Numeric> &ticks, const std::vector<std::string> &labels = {}, const std::map<std::string, std::string>& keywords = {})
+{
+ assert(labels.size() == 0 || ticks.size() == labels.size());
+
+ detail::_interpreter::get();
+
+ // using numpy array
+ PyObject* ticksarray = detail::get_array(ticks);
+
+ PyObject* args;
+ if(labels.size() == 0) {
+ // construct positional args
+ args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, ticksarray);
+ } else {
+ // make tuple of tick labels
+ PyObject* labelstuple = PyTuple_New(labels.size());
+ for (size_t i = 0; i < labels.size(); i++)
+ PyTuple_SetItem(labelstuple, i, PyUnicode_FromString(labels[i].c_str()));
+
+ // construct positional args
+ args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, ticksarray);
+ PyTuple_SetItem(args, 1, labelstuple);
+ }
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_yticks, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if(!res) throw std::runtime_error("Call to yticks() failed");
+
+ Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void yticks(const std::vector<Numeric> &ticks, const std::map<std::string, std::string>& keywords)
+{
+ yticks(ticks, {}, keywords);
+}
+
+template <typename Numeric> inline void margins(Numeric margin)
+{
+ // construct positional args
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin));
+
+ PyObject* res =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
+ if (!res)
+ throw std::runtime_error("Call to margins() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+template <typename Numeric> inline void margins(Numeric margin_x, Numeric margin_y)
+{
+ // construct positional args
+ PyObject* args = PyTuple_New(2);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(margin_x));
+ PyTuple_SetItem(args, 1, PyFloat_FromDouble(margin_y));
+
+ PyObject* res =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_margins, args);
+ if (!res)
+ throw std::runtime_error("Call to margins() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+
+inline void tick_params(const std::map<std::string, std::string>& keywords, const std::string axis = "both")
+{
+ detail::_interpreter::get();
+
+ // construct positional args
+ PyObject* args;
+ args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyString_FromString(axis.c_str()));
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for (std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_tick_params, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (!res) throw std::runtime_error("Call to tick_params() failed");
+
+ Py_DECREF(res);
+}
+
+inline void subplot(long nrows, long ncols, long plot_number)
+{
+ detail::_interpreter::get();
+
+ // construct positional args
+ PyObject* args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(nrows));
+ PyTuple_SetItem(args, 1, PyFloat_FromDouble(ncols));
+ PyTuple_SetItem(args, 2, PyFloat_FromDouble(plot_number));
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot, args);
+ if(!res) throw std::runtime_error("Call to subplot() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+inline void subplot2grid(long nrows, long ncols, long rowid=0, long colid=0, long rowspan=1, long colspan=1)
+{
+ detail::_interpreter::get();
+
+ PyObject* shape = PyTuple_New(2);
+ PyTuple_SetItem(shape, 0, PyLong_FromLong(nrows));
+ PyTuple_SetItem(shape, 1, PyLong_FromLong(ncols));
+
+ PyObject* loc = PyTuple_New(2);
+ PyTuple_SetItem(loc, 0, PyLong_FromLong(rowid));
+ PyTuple_SetItem(loc, 1, PyLong_FromLong(colid));
+
+ PyObject* args = PyTuple_New(4);
+ PyTuple_SetItem(args, 0, shape);
+ PyTuple_SetItem(args, 1, loc);
+ PyTuple_SetItem(args, 2, PyLong_FromLong(rowspan));
+ PyTuple_SetItem(args, 3, PyLong_FromLong(colspan));
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_subplot2grid, args);
+ if(!res) throw std::runtime_error("Call to subplot2grid() failed.");
+
+ Py_DECREF(shape);
+ Py_DECREF(loc);
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+inline void title(const std::string &titlestr, const std::map<std::string, std::string> &keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* pytitlestr = PyString_FromString(titlestr.c_str());
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pytitlestr);
+
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_title, args, kwargs);
+ if(!res) throw std::runtime_error("Call to title() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+inline void suptitle(const std::string &suptitlestr, const std::map<std::string, std::string> &keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* pysuptitlestr = PyString_FromString(suptitlestr.c_str());
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pysuptitlestr);
+
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_suptitle, args, kwargs);
+ if(!res) throw std::runtime_error("Call to suptitle() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+inline void axis(const std::string &axisstr)
+{
+ detail::_interpreter::get();
+
+ PyObject* str = PyString_FromString(axisstr.c_str());
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, str);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_axis, args);
+ if(!res) throw std::runtime_error("Call to title() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+inline void axhline(double y, double xmin = 0., double xmax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+ detail::_interpreter::get();
+
+ // construct positional args
+ PyObject* args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(y));
+ PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmin));
+ PyTuple_SetItem(args, 2, PyFloat_FromDouble(xmax));
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axhline, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if(res) Py_DECREF(res);
+}
+
+inline void axvline(double x, double ymin = 0., double ymax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+ detail::_interpreter::get();
+
+ // construct positional args
+ PyObject* args = PyTuple_New(3);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(x));
+ PyTuple_SetItem(args, 1, PyFloat_FromDouble(ymin));
+ PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymax));
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axvline, args, kwargs);
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if(res) Py_DECREF(res);
+}
+
+inline void axvspan(double xmin, double xmax, double ymin = 0., double ymax = 1., const std::map<std::string, std::string>& keywords = std::map<std::string, std::string>())
+{
+ // construct positional args
+ PyObject* args = PyTuple_New(4);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(xmin));
+ PyTuple_SetItem(args, 1, PyFloat_FromDouble(xmax));
+ PyTuple_SetItem(args, 2, PyFloat_FromDouble(ymin));
+ PyTuple_SetItem(args, 3, PyFloat_FromDouble(ymax));
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ if (it->first == "linewidth" || it->first == "alpha") {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyFloat_FromDouble(std::stod(it->second)));
+ } else {
+ PyDict_SetItemString(kwargs, it->first.c_str(),
+ PyString_FromString(it->second.c_str()));
+ }
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_axvspan, args, kwargs);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+
+ if(res) Py_DECREF(res);
+}
+
+inline void xlabel(const std::string &str, const std::map<std::string, std::string> &keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* pystr = PyString_FromString(str.c_str());
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pystr);
+
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_xlabel, args, kwargs);
+ if(!res) throw std::runtime_error("Call to xlabel() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+inline void ylabel(const std::string &str, const std::map<std::string, std::string>& keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject* pystr = PyString_FromString(str.c_str());
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pystr);
+
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_ylabel, args, kwargs);
+ if(!res) throw std::runtime_error("Call to ylabel() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+inline void set_zlabel(const std::string &str, const std::map<std::string, std::string>& keywords = {})
+{
+ detail::_interpreter::get();
+
+ // Same as with plot_surface: We lazily load the modules here the first time
+ // this function is called because I'm not sure that we can assume "matplotlib
+ // installed" implies "mpl_toolkits installed" on all platforms, and we don't
+ // want to require it for people who don't need 3d plots.
+ static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
+ if (!mpl_toolkitsmod) {
+ PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
+ PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
+ if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
+
+ mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
+ Py_DECREF(mpl_toolkits);
+ if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
+
+ axis3dmod = PyImport_Import(axis3d);
+ Py_DECREF(axis3d);
+ if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
+ }
+
+ PyObject* pystr = PyString_FromString(str.c_str());
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pystr);
+
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject *ax =
+ PyObject_CallObject(detail::_interpreter::get().s_python_function_gca,
+ detail::_interpreter::get().s_python_empty_tuple);
+ if (!ax) throw std::runtime_error("Call to gca() failed.");
+ Py_INCREF(ax);
+
+ PyObject *zlabel = PyObject_GetAttrString(ax, "set_zlabel");
+ if (!zlabel) throw std::runtime_error("Attribute set_zlabel not found.");
+ Py_INCREF(zlabel);
+
+ PyObject *res = PyObject_Call(zlabel, args, kwargs);
+ if (!res) throw std::runtime_error("Call to set_zlabel() failed.");
+ Py_DECREF(zlabel);
+
+ Py_DECREF(ax);
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ if (res) Py_DECREF(res);
+}
+
+inline void grid(bool flag)
+{
+ detail::_interpreter::get();
+
+ PyObject* pyflag = flag ? Py_True : Py_False;
+ Py_INCREF(pyflag);
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pyflag);
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_grid, args);
+ if(!res) throw std::runtime_error("Call to grid() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+inline void show(const bool block = true)
+{
+ detail::_interpreter::get();
+
+ PyObject* res;
+ if(block)
+ {
+ res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_show,
+ detail::_interpreter::get().s_python_empty_tuple);
+ }
+ else
+ {
+ PyObject *kwargs = PyDict_New();
+ PyDict_SetItemString(kwargs, "block", Py_False);
+ res = PyObject_Call( detail::_interpreter::get().s_python_function_show, detail::_interpreter::get().s_python_empty_tuple, kwargs);
+ Py_DECREF(kwargs);
+ }
+
+
+ if (!res) throw std::runtime_error("Call to show() failed.");
+
+ Py_DECREF(res);
+}
+
+inline void close()
+{
+ detail::_interpreter::get();
+
+ PyObject* res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_close,
+ detail::_interpreter::get().s_python_empty_tuple);
+
+ if (!res) throw std::runtime_error("Call to close() failed.");
+
+ Py_DECREF(res);
+}
+
+inline void xkcd() {
+ detail::_interpreter::get();
+
+ PyObject* res;
+ PyObject *kwargs = PyDict_New();
+
+ res = PyObject_Call(detail::_interpreter::get().s_python_function_xkcd,
+ detail::_interpreter::get().s_python_empty_tuple, kwargs);
+
+ Py_DECREF(kwargs);
+
+ if (!res)
+ throw std::runtime_error("Call to show() failed.");
+
+ Py_DECREF(res);
+}
+
+inline void draw()
+{
+ detail::_interpreter::get();
+
+ PyObject* res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_draw,
+ detail::_interpreter::get().s_python_empty_tuple);
+
+ if (!res) throw std::runtime_error("Call to draw() failed.");
+
+ Py_DECREF(res);
+}
+
+template<typename Numeric>
+inline void pause(Numeric interval)
+{
+ detail::_interpreter::get();
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyFloat_FromDouble(interval));
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_pause, args);
+ if(!res) throw std::runtime_error("Call to pause() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(res);
+}
+
+inline void save(const std::string& filename, const int dpi=0)
+{
+ detail::_interpreter::get();
+
+ PyObject* pyfilename = PyString_FromString(filename.c_str());
+
+ PyObject* args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, pyfilename);
+
+ PyObject* kwargs = PyDict_New();
+
+ if(dpi > 0)
+ {
+ PyDict_SetItemString(kwargs, "dpi", PyLong_FromLong(dpi));
+ }
+
+ PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_save, args, kwargs);
+ if (!res) throw std::runtime_error("Call to save() failed.");
+
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(res);
+}
+
+inline void rcparams(const std::map<std::string, std::string>& keywords = {}) {
+ detail::_interpreter::get();
+ PyObject* args = PyTuple_New(0);
+ PyObject* kwargs = PyDict_New();
+ for (auto it = keywords.begin(); it != keywords.end(); ++it) {
+ if ("text.usetex" == it->first)
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyLong_FromLong(std::stoi(it->second.c_str())));
+ else PyDict_SetItemString(kwargs, it->first.c_str(), PyString_FromString(it->second.c_str()));
+ }
+
+ PyObject * update = PyObject_GetAttrString(detail::_interpreter::get().s_python_function_rcparams, "update");
+ PyObject * res = PyObject_Call(update, args, kwargs);
+ if(!res) throw std::runtime_error("Call to rcParams.update() failed.");
+ Py_DECREF(args);
+ Py_DECREF(kwargs);
+ Py_DECREF(update);
+ Py_DECREF(res);
+}
+
+inline void clf() {
+ detail::_interpreter::get();
+
+ PyObject *res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_clf,
+ detail::_interpreter::get().s_python_empty_tuple);
+
+ if (!res) throw std::runtime_error("Call to clf() failed.");
+
+ Py_DECREF(res);
+}
+
+inline void cla() {
+ detail::_interpreter::get();
+
+ PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_cla,
+ detail::_interpreter::get().s_python_empty_tuple);
+
+ if (!res)
+ throw std::runtime_error("Call to cla() failed.");
+
+ Py_DECREF(res);
+}
+
+inline void ion() {
+ detail::_interpreter::get();
+
+ PyObject *res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_ion,
+ detail::_interpreter::get().s_python_empty_tuple);
+
+ if (!res) throw std::runtime_error("Call to ion() failed.");
+
+ Py_DECREF(res);
+}
+
+inline std::vector<std::array<double, 2>> ginput(const int numClicks = 1, const std::map<std::string, std::string>& keywords = {})
+{
+ detail::_interpreter::get();
+
+ PyObject *args = PyTuple_New(1);
+ PyTuple_SetItem(args, 0, PyLong_FromLong(numClicks));
+
+ // construct keyword args
+ PyObject* kwargs = PyDict_New();
+ for(std::map<std::string, std::string>::const_iterator it = keywords.begin(); it != keywords.end(); ++it)
+ {
+ PyDict_SetItemString(kwargs, it->first.c_str(), PyUnicode_FromString(it->second.c_str()));
+ }
+
+ PyObject* res = PyObject_Call(
+ detail::_interpreter::get().s_python_function_ginput, args, kwargs);
+
+ Py_DECREF(kwargs);
+ Py_DECREF(args);
+ if (!res) throw std::runtime_error("Call to ginput() failed.");
+
+ const size_t len = PyList_Size(res);
+ std::vector<std::array<double, 2>> out;
+ out.reserve(len);
+ for (size_t i = 0; i < len; i++) {
+ PyObject *current = PyList_GetItem(res, i);
+ std::array<double, 2> position;
+ position[0] = PyFloat_AsDouble(PyTuple_GetItem(current, 0));
+ position[1] = PyFloat_AsDouble(PyTuple_GetItem(current, 1));
+ out.push_back(position);
+ }
+ Py_DECREF(res);
+
+ return out;
+}
+
+// Actually, is there any reason not to call this automatically for every plot?
+inline void tight_layout() {
+ detail::_interpreter::get();
+
+ PyObject *res = PyObject_CallObject(
+ detail::_interpreter::get().s_python_function_tight_layout,
+ detail::_interpreter::get().s_python_empty_tuple);
+
+ if (!res) throw std::runtime_error("Call to tight_layout() failed.");
+
+ Py_DECREF(res);
+}
+
+// Support for variadic plot() and initializer lists:
+
+namespace detail {
+
+template<typename T>
+using is_function = typename std::is_function<std::remove_pointer<std::remove_reference<T>>>::type;
+
+template<bool obj, typename T>
+struct is_callable_impl;
+
+template<typename T>
+struct is_callable_impl<false, T>
+{
+ typedef is_function<T> type;
+}; // a non-object is callable iff it is a function
+
+template<typename T>
+struct is_callable_impl<true, T>
+{
+ struct Fallback { void operator()(); };
+ struct Derived : T, Fallback { };
+
+ template<typename U, U> struct Check;
+
+ template<typename U>
+ static std::true_type test( ... ); // use a variadic function to make sure (1) it accepts everything and (2) its always the worst match
+
+ template<typename U>
+ static std::false_type test( Check<void(Fallback::*)(), &U::operator()>* );
+
+public:
+ typedef decltype(test<Derived>(nullptr)) type;
+ typedef decltype(&Fallback::operator()) dtype;
+ static constexpr bool value = type::value;
+}; // an object is callable iff it defines operator()
+
+template<typename T>
+struct is_callable
+{
+ // dispatch to is_callable_impl<true, T> or is_callable_impl<false, T> depending on whether T is of class type or not
+ typedef typename is_callable_impl<std::is_class<T>::value, T>::type type;
+};
+
+template<typename IsYDataCallable>
+struct plot_impl { };
+
+template<>
+struct plot_impl<std::false_type>
+{
+ template<typename IterableX, typename IterableY>
+ bool operator()(const IterableX& x, const IterableY& y, const std::string& format)
+ {
+ detail::_interpreter::get();
+
+ // 2-phase lookup for distance, begin, end
+ using std::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