From c6af1e3f013acb18b751c32fe141de06b8342ed1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joan=20Vallv=C3=A9=20Navarro?= <jvallve@iri.upc.edu>
Date: Thu, 21 Oct 2021 16:22:19 +0200
Subject: [PATCH] removed plot dependency
---
test/CMakeLists.txt | 4 +-
test/gtest_loop_closure_falko.cpp | 189 +--
test/matplotlibcpp.h | 2555 -----------------------------
3 files changed, 63 insertions(+), 2685 deletions(-)
delete mode 100644 test/matplotlibcpp.h
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index aa60e80..1669d5d 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -8,7 +8,6 @@ include_directories(${GTEST_INCLUDE_DIRS})
INCLUDE_DIRECTORIES(../src)
INCLUDE_DIRECTORIES(/data)
FIND_PACKAGE(Eigen3 3.3 REQUIRED)
-find_package(PythonLibs 2.7)
INCLUDE_DIRECTORIES(${EIGEN3_INCLUDE_DIRS})
############# USE THIS TEST AS AN EXAMPLE ####################
@@ -24,5 +23,4 @@ gnss_utils_add_gtest(gtest_example gtest_example.cpp)
target_link_libraries(gtest_example ${PROJECT_NAME})
gnss_utils_add_gtest(gtest_loop_closure_falko gtest_loop_closure_falko.cpp ${PROJECT_SOURCE_DIR}/test/data)
-target_link_libraries(gtest_loop_closure_falko ${PROJECT_NAME} ${PYTHON_LIBRARIES})
-target_include_directories(gtest_loop_closure_falko PRIVATE ${PYTHON_INCLUDE_DIRS})
+target_link_libraries(gtest_loop_closure_falko ${PROJECT_NAME})
diff --git a/test/gtest_loop_closure_falko.cpp b/test/gtest_loop_closure_falko.cpp
index be5197e..a51c576 100644
--- a/test/gtest_loop_closure_falko.cpp
+++ b/test/gtest_loop_closure_falko.cpp
@@ -1,12 +1,9 @@
-#include "../src/loop_closure_base.h"
-#include "../src/loop_closure_falko.h"
-// #include "testData2.h"
+#include "loop_closure_base.h"
+#include "loop_closure_falko.h"
#include "data/scan_data.h"
#include "gtest/utils_gtest.h"
-#include "matplotlibcpp.h"
using namespace laserscanutils;
-namespace plt = matplotlibcpp;
TEST(loop_closure_falko, TestLoopClosureFalkoAllFunctions)
{
@@ -19,10 +16,10 @@ TEST(loop_closure_falko, TestLoopClosureFalkoAllFunctions)
laser_params.angle_step_ = 0.00701248;
laser_params.range_max_ = 50;
for (int i = 0; i < scan_size; i++)
- {
- scan.ranges_raw_.push_back(testRanges1[i]);
- scan2.ranges_raw_.push_back(testRanges2[i]);
- }
+ {
+ scan.ranges_raw_.push_back(testRanges1[i]);
+ scan2.ranges_raw_.push_back(testRanges2[i]);
+ }
ParameterLoopClosureFalko param;
param.matcher_distance_th_ = 0.3;
@@ -30,15 +27,16 @@ TEST(loop_closure_falko, TestLoopClosureFalkoAllFunctions)
// Test convert2LaserScanFALKO
std::shared_ptr<falkolib::LaserScan> scan_falko = loop_cl_falko.convert2LaserScanFALKO(scan, laser_params);
- int firstPoint = scan_falko->ranges[0];
+ int firstPoint = scan_falko->ranges[0];
ASSERT_EQ(firstPoint, 250);
// Test extractScene2
- auto new_scene = std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko.extractScene(scan,
- laser_params)); auto new_scene2 =
- std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko.extractScene(scan2, laser_params)); int detectedKeypoints
- = new_scene->keypoints_list_.size(); int detectedDescriptors = new_scene->descriptors_list_.size();
+ auto new_scene = std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko.extractScene(scan, laser_params));
+ auto new_scene2 = std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko.extractScene(scan2, laser_params));
+
+ int detectedKeypoints = new_scene->keypoints_list_.size();
+ int detectedDescriptors = new_scene->descriptors_list_.size();
ASSERT_EQ(detectedKeypoints, 18);
ASSERT_EQ(detectedDescriptors, 18);
@@ -72,11 +70,11 @@ TEST(loop_closure_falko, TestDescriptorsRotation)
laser_params.range_max_ = 50;
for (int i = 0; i < scan_size; i++)
- {
- scan_1.ranges_raw_.push_back(testRanges1[i]);
- scan_2.ranges_raw_.push_back(testRanges1[i]);
- scan2.ranges_raw_.push_back(testRanges2[i]);
- }
+ {
+ scan_1.ranges_raw_.push_back(testRanges1[i]);
+ scan_2.ranges_raw_.push_back(testRanges1[i]);
+ scan2.ranges_raw_.push_back(testRanges2[i]);
+ }
// Rotate scans
int rot = 800;
std::rotate(scan_2.ranges_raw_.begin(), scan_2.ranges_raw_.begin() + rot, scan_2.ranges_raw_.end());
@@ -100,74 +98,22 @@ TEST(loop_closure_falko, TestDescriptorsRotation)
double asso_dist[key_1.size()][key_2.size()];
double min_dist_vector[key_1.size()];
for (int i = 0; i < desc_1.size(); i++)
+ {
+ double min_dist = 1000;
+ int asso_number;
+ for (int j = 0; j < desc_2.size(); j++)
{
- double min_dist = 1000;
- int asso_number;
- for (int j = 0; j < desc_2.size(); j++)
- {
-
- acum_distance += desc_1[i].distance(desc_2[j]);
- asso_dist[i][j] = desc_1[i].distance(desc_2[j]);
- if (asso_dist[i][j] < min_dist)
- {
- min_dist = asso_dist[i][j];
- asso_number = j;
- }
- }
- // std::cout << "pair : " << i << " , " << asso_number << " , distance : " << min_dist << std::endl;
- }
- // for (int i = 0; i < desc_1.size(); i++)
- // {
- // for (int j = 0; j < desc_2.size(); j++)
- // {
- // if (key_1[i].index == key_2[j].index + rot or key_1[i].index == key_2[j].index + rot + 1 or
- // key_1[i].index == key_2[j].index - 1440 + rot)
- // {
-
- // std::cout << "pair : " << i << " , " << j
- // << " , distance : " << desc_1[i].distance(desc_2[j]) << std::endl;
-
- // acum_distance += desc_1[i].distance(desc_2[j]);
-
- // // grid to x and y
- // std::vector<int> x_pos, x_pos_rotated;
- // std::vector<int> y_pos, y_pos_rotated;
-
- // int desc_1_number = i;
- // int desc_2_number = j;
- // auto grid_1 = new_scene->descriptors_list_rotated[i].grid;
- // auto grid_2 = new_scene_2->descriptors_list_rotated[j].grid;
-
- // for (int i = 0; i < radialRingNumber; i++)
- // for (int j = 0; j < circularSectorNumber; j++)
- // {
- // if (grid_1[i][j] > 0)
- // {
- // x_pos.push_back(i);
- // y_pos.push_back(j);
- // }
-
- // if (grid_2[i][j] > 0)
- // {
- // x_pos_rotated.push_back(i);
- // y_pos_rotated.push_back(j);
- // }
- // }
-
- // // Plotting descriptors
- // // plt::title("NNMatcher BSC only keypoints");
- // // plt::subplot(2, 1, 1);
- // // plt::xlabel(" descriprtor not rotated");
- // // plt::plot(x_pos, y_pos, "ob");
-
- // // plt::subplot(2, 1, 2);
- // // plt::xlabel(" descriprtor rotated");
- // // plt::plot(x_pos_rotated, y_pos_rotated, "or");
- // // plt::show();
- // }
- // }
- // }
+ acum_distance += desc_1[i].distance(desc_2[j]);
+ asso_dist[i][j] = desc_1[i].distance(desc_2[j]);
+ if (asso_dist[i][j] < min_dist)
+ {
+ min_dist = asso_dist[i][j];
+ asso_number = j;
+ }
+ }
+ // std::cout << "pair : " << i << " , " << asso_number << " , distance : " << min_dist << std::endl;
+ }
}
TEST(loop_closure_falko, TestMatch)
@@ -183,11 +129,11 @@ TEST(loop_closure_falko, TestMatch)
laser_params.range_max_ = 50;
for (int i = 0; i < scan_size; i++)
- {
- scan_1.ranges_raw_.push_back(testRanges1[i]);
- scan_2.ranges_raw_.push_back(testRanges1[i]);
- scan_3.ranges_raw_.push_back(testRanges2[i]);
- }
+ {
+ scan_1.ranges_raw_.push_back(testRanges1[i]);
+ scan_2.ranges_raw_.push_back(testRanges1[i]);
+ scan_3.ranges_raw_.push_back(testRanges2[i]);
+ }
// Rotate scans
int rot = 800;
@@ -205,6 +151,8 @@ TEST(loop_closure_falko, TestMatch)
auto match_1_2 = loop_cl_falko.matchScene(new_scene_1, new_scene_2);
+ ASSERT_TRUE(match_1_2->match);
+
std::vector<std::pair<int, int>> asso_1_2;
for (auto asso : match_1_2->associations)
if (asso.second != -1)
@@ -227,10 +175,10 @@ TEST(loop_closure_falko, TestMatch2)
// ** TEST WITH TARGET AND REFERENCE SCENE
// std::cout << "scan size : " << target_scan_1.size() << std::endl;
for (int i = 0; i < target_scan_1.size(); i++)
- {
- scan_target.ranges_raw_.push_back(target_scan_1[i]);
- scan_ref.ranges_raw_.push_back(reference_scan_1[i]);
- }
+ {
+ scan_target.ranges_raw_.push_back(target_scan_1[i]);
+ scan_ref.ranges_raw_.push_back(reference_scan_1[i]);
+ }
ParameterLoopClosureFalko param;
param.use_descriptors_ = true;
@@ -244,10 +192,8 @@ TEST(loop_closure_falko, TestMatch2)
laser_params.angle_step_ = 0.00701248;
LoopClosureFalkoAht<bsc, bscExtractor> loop_cl_falko_2(param);
- auto new_scene_target =
- std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko_2.extractScene(scan_target, laser_params));
- auto new_scene_reference =
- std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko_2.extractScene(scan_ref, laser_params));
+ auto new_scene_target = std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko_2.extractScene(scan_target, laser_params));
+ auto new_scene_reference = std::static_pointer_cast<SceneFalko<bsc>>(loop_cl_falko_2.extractScene(scan_ref, laser_params));
// std::cout << "keypoints target size : " << new_scene_target->keypoints_list_.size() << std::endl;
// std::cout << "keypoints reference size : " << new_scene_reference->keypoints_list_.size() << std::endl;
@@ -255,10 +201,10 @@ TEST(loop_closure_falko, TestMatch2)
auto match_r_t = loop_cl_falko_2.matchScene(new_scene_reference, new_scene_target);
for (int i = 0; i < match_r_t->associations.size(); i++)
if (match_r_t->associations[i].second != -1)
- {
- // std::cout << "id first : " << match_r_t->associations[i].first << std::endl;
- // std::cout << "id second : " << match_r_t->associations[i].second << std::endl;
- }
+ {
+ std::cout << "id first : " << match_r_t->associations[i].first << std::endl;
+ std::cout << "id second : " << match_r_t->associations[i].second << std::endl;
+ }
// std::cout << "transform : " << match_r_t->transform_vector.transpose() << std::endl;
@@ -270,40 +216,29 @@ TEST(loop_closure_falko, TestMatch2)
// Plotting keypoints scenes
for (int i = 0; i < key_ref.size(); i++)
- {
- x_ref_all.push_back(key_ref[i].point.x());
- y_ref_all.push_back(key_ref[i].point.y());
- }
+ {
+ x_ref_all.push_back(key_ref[i].point.x());
+ y_ref_all.push_back(key_ref[i].point.y());
+ }
for (int i = 0; i < key_target.size(); i++)
- {
- x_target_all.push_back(key_target[i].point.x());
- y_target_all.push_back(key_target[i].point.y());
- }
-
- plt::title("AHTMatcher BSC without descriptors");
- plt::plot(x_ref_all, y_ref_all, "ob");
- plt::plot(x_target_all, y_target_all, "or");
+ {
+ x_target_all.push_back(key_target[i].point.x());
+ y_target_all.push_back(key_target[i].point.y());
+ }
std::vector<double> x_ref, x_target;
std::vector<double> y_ref, y_target;
for (auto asso : match_r_t->associations)
if (asso.second != -1)
- {
- // auto a = key_ref[asso.first].point.x();
- x_ref.push_back(key_ref[asso.first].point.x());
- y_ref.push_back(key_ref[asso.first].point.y());
-
- x_target.push_back(key_target[asso.second].point.x());
- y_target.push_back(key_target[asso.second].point.y());
- }
-
- for (int i = 0; i < x_ref.size(); i++)
{
- plt::plot({x_ref[i], x_target[i]}, {y_ref[i], y_target[i]}, "g");
- }
+ // auto a = key_ref[asso.first].point.x();
+ x_ref.push_back(key_ref[asso.first].point.x());
+ y_ref.push_back(key_ref[asso.first].point.y());
- // plt::show();
+ x_target.push_back(key_target[asso.second].point.x());
+ y_target.push_back(key_target[asso.second].point.y());
+ }
}
int main(int argc, char **argv)
diff --git a/test/matplotlibcpp.h b/test/matplotlibcpp.h
deleted file mode 100644
index 23553ae..0000000
--- a/test/matplotlibcpp.h
+++ /dev/null
@@ -1,2555 +0,0 @@
-#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>
-
-#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_axvline;
- PyObject *s_python_function_axvspan;
- PyObject *s_python_function_xlabel;
- PyObject *s_python_function_ylabel;
- PyObject *s_python_function_gca;
- PyObject *s_python_function_xticks;
- PyObject *s_python_function_yticks;
- PyObject* s_python_function_margins;
- PyObject *s_python_function_tick_params;
- PyObject *s_python_function_grid;
- PyObject* s_python_function_cla;
- PyObject *s_python_function_clf;
- PyObject *s_python_function_errorbar;
- PyObject *s_python_function_annotate;
- PyObject *s_python_function_tight_layout;
- PyObject *s_python_colormap;
- PyObject *s_python_empty_tuple;
- PyObject *s_python_function_stem;
- PyObject *s_python_function_xkcd;
- PyObject *s_python_function_text;
- PyObject *s_python_function_suptitle;
- PyObject *s_python_function_bar;
- PyObject *s_python_function_barh;
- PyObject *s_python_function_colorbar;
- PyObject *s_python_function_subplots_adjust;
-
-
- /* For now, _interpreter is implemented as a singleton since its 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;
- char ** argm = (char **)(argv);
- PySys_SetArgv(argc, argm);
-
-#ifndef WITHOUT_NUMPY
- import_numpy(); // initialize numpy C-API
-#endif
-
- PyObject* matplotlibname = PyString_FromString("matplotlib");
- PyObject* pyplotname = PyString_FromString("matplotlib.pyplot");
- PyObject* cmname = PyString_FromString("matplotlib.cm");
- PyObject* pylabname = PyString_FromString("pylab");
- if (!pyplotname || !pylabname || !matplotlibname || !cmname) {
- throw std::runtime_error("couldnt create string");
- }
-
- PyObject* matplotlib = PyImport_Import(matplotlibname);
- Py_DECREF(matplotlibname);
- if (!matplotlib) {
- PyErr_Print();
- throw std::runtime_error("Error loading module matplotlib!");
- }
-
- // matplotlib.use() must be called *before* pylab, matplotlib.pyplot,
- // or matplotlib.backends is imported for the first time
- if (!s_backend.empty()) {
- PyObject_CallMethod(matplotlib, const_cast<char*>("use"), const_cast<char*>("s"), s_backend.c_str());
- }
-
- PyObject* pymod = PyImport_Import(pyplotname);
- Py_DECREF(pyplotname);
- if (!pymod) { throw std::runtime_error("Error loading module matplotlib.pyplot!"); }
-
- s_python_colormap = PyImport_Import(cmname);
- Py_DECREF(cmname);
- if (!s_python_colormap) { throw std::runtime_error("Error loading module matplotlib.cm!"); }
-
- PyObject* pylabmod = PyImport_Import(pylabname);
- Py_DECREF(pylabname);
- if (!pylabmod) { throw std::runtime_error("Error loading module pylab!"); }
-
- s_python_function_arrow = safe_import(pymod, "arrow");
- s_python_function_show = safe_import(pymod, "show");
- s_python_function_close = safe_import(pymod, "close");
- s_python_function_draw = safe_import(pymod, "draw");
- s_python_function_pause = safe_import(pymod, "pause");
- s_python_function_figure = safe_import(pymod, "figure");
- s_python_function_fignum_exists = safe_import(pymod, "fignum_exists");
- s_python_function_plot = safe_import(pymod, "plot");
- s_python_function_quiver = safe_import(pymod, "quiver");
- s_python_function_contour = safe_import(pymod, "contour");
- s_python_function_semilogx = safe_import(pymod, "semilogx");
- s_python_function_semilogy = safe_import(pymod, "semilogy");
- s_python_function_loglog = safe_import(pymod, "loglog");
- s_python_function_fill = safe_import(pymod, "fill");
- s_python_function_fill_between = safe_import(pymod, "fill_between");
- s_python_function_hist = safe_import(pymod,"hist");
- s_python_function_scatter = safe_import(pymod,"scatter");
- s_python_function_boxplot = safe_import(pymod,"boxplot");
- s_python_function_subplot = safe_import(pymod, "subplot");
- s_python_function_subplot2grid = safe_import(pymod, "subplot2grid");
- s_python_function_legend = safe_import(pymod, "legend");
- s_python_function_ylim = safe_import(pymod, "ylim");
- s_python_function_title = safe_import(pymod, "title");
- s_python_function_axis = safe_import(pymod, "axis");
- s_python_function_axvline = safe_import(pymod, "axvline");
- s_python_function_axvspan = safe_import(pymod, "axvspan");
- s_python_function_xlabel = safe_import(pymod, "xlabel");
- s_python_function_ylabel = safe_import(pymod, "ylabel");
- s_python_function_gca = safe_import(pymod, "gca");
- s_python_function_xticks = safe_import(pymod, "xticks");
- s_python_function_yticks = safe_import(pymod, "yticks");
- s_python_function_margins = safe_import(pymod, "margins");
- s_python_function_tick_params = safe_import(pymod, "tick_params");
- s_python_function_grid = safe_import(pymod, "grid");
- s_python_function_xlim = safe_import(pymod, "xlim");
- s_python_function_ion = safe_import(pymod, "ion");
- s_python_function_ginput = safe_import(pymod, "ginput");
- s_python_function_save = safe_import(pylabmod, "savefig");
- s_python_function_annotate = safe_import(pymod,"annotate");
- s_python_function_cla = safe_import(pymod, "cla");
- s_python_function_clf = safe_import(pymod, "clf");
- s_python_function_errorbar = safe_import(pymod, "errorbar");
- s_python_function_tight_layout = safe_import(pymod, "tight_layout");
- s_python_function_stem = safe_import(pymod, "stem");
- s_python_function_xkcd = safe_import(pymod, "xkcd");
- s_python_function_text = safe_import(pymod, "text");
- s_python_function_suptitle = safe_import(pymod, "suptitle");
- s_python_function_bar = safe_import(pymod,"bar");
- s_python_function_barh = safe_import(pymod, "barh");
- s_python_function_colorbar = PyObject_GetAttrString(pymod, "colorbar");
- s_python_function_subplots_adjust = safe_import(pymod,"subplots_adjust");
-#ifndef WITHOUT_NUMPY
- s_python_function_imshow = safe_import(pymod, "imshow");
-#endif
- s_python_empty_tuple = PyTuple_New(0);
- }
-
- ~_interpreter() {
- Py_Finalize();
- }
-};
-
-} // 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; };
-// TODO: add int, long, etc.
-
-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>())
-{
- detail::_interpreter::get();
-
- // We lazily load the modules here the first time this function is called
- // because I'm not sure that we can assume "matplotlib installed" implies
- // "mpl_toolkits installed" on all platforms, and we don't want to require
- // it for people who don't need 3d plots.
- static PyObject *mpl_toolkitsmod = nullptr, *axis3dmod = nullptr;
- if (!mpl_toolkitsmod) {
- detail::_interpreter::get();
-
- PyObject* mpl_toolkits = PyString_FromString("mpl_toolkits");
- PyObject* axis3d = PyString_FromString("mpl_toolkits.mplot3d");
- if (!mpl_toolkits || !axis3d) { throw std::runtime_error("couldnt create string"); }
-
- mpl_toolkitsmod = PyImport_Import(mpl_toolkits);
- Py_DECREF(mpl_toolkits);
- if (!mpl_toolkitsmod) { throw std::runtime_error("Error loading module mpl_toolkits!"); }
-
- axis3dmod = PyImport_Import(axis3d);
- Py_DECREF(axis3d);
- if (!axis3dmod) { throw std::runtime_error("Error loading module mpl_toolkits.mplot3d!"); }
- }
-
- assert(x.size() == y.size());
- assert(y.size() == z.size());
-
- // using numpy arrays
- PyObject *xarray = detail::get_2darray(x);
- PyObject *yarray = detail::get_2darray(y);
- PyObject *zarray = detail::get_2darray(z);
-
- // construct positional args
- PyObject *args = PyTuple_New(3);
- PyTuple_SetItem(args, 0, xarray);
- PyTuple_SetItem(args, 1, yarray);
- PyTuple_SetItem(args, 2, zarray);
-
- // Build up the kw args.
- PyObject *kwargs = PyDict_New();
- PyDict_SetItemString(kwargs, "rstride", PyInt_FromLong(1));
- PyDict_SetItemString(kwargs, "cstride", PyInt_FromLong(1));
-
- PyObject *python_colormap_coolwarm = PyObject_GetAttrString(
- detail::_interpreter::get().s_python_colormap, "coolwarm");
-
- PyDict_SetItemString(kwargs, "cmap", python_colormap_coolwarm);
-
- for (std::map<std::string, std::string>::const_iterator it = keywords.begin();
- it != keywords.end(); ++it) {
- PyDict_SetItemString(kwargs, it->first.c_str(),
- PyString_FromString(it->second.c_str()));
- }
-
-
- PyObject *fig =
- PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
- detail::_interpreter::get().s_python_empty_tuple);
- if (!fig) throw std::runtime_error("Call to figure() failed.");
-
- PyObject *gca_kwargs = PyDict_New();
- PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
-
- PyObject *gca = PyObject_GetAttrString(fig, "gca");
- if (!gca) throw std::runtime_error("No gca");
- Py_INCREF(gca);
- PyObject *axis = PyObject_Call(
- gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
-
- if (!axis) throw std::runtime_error("No axis");
- Py_INCREF(axis);
-
- Py_DECREF(gca);
- Py_DECREF(gca_kwargs);
-
- PyObject *plot_surface = PyObject_GetAttrString(axis, "plot_surface");
- if (!plot_surface) throw std::runtime_error("No surface");
- Py_INCREF(plot_surface);
- PyObject *res = PyObject_Call(plot_surface, args, kwargs);
- if (!res) throw std::runtime_error("failed surface");
- Py_DECREF(plot_surface);
-
- Py_DECREF(axis);
- Py_DECREF(args);
- Py_DECREF(kwargs);
- if (res) Py_DECREF(res);
-}
-#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>())
-{
- 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 =
- PyObject_CallObject(detail::_interpreter::get().s_python_function_figure,
- detail::_interpreter::get().s_python_empty_tuple);
- if (!fig) throw std::runtime_error("Call to figure() failed.");
-
- PyObject *gca_kwargs = PyDict_New();
- PyDict_SetItemString(gca_kwargs, "projection", PyString_FromString("3d"));
-
- PyObject *gca = PyObject_GetAttrString(fig, "gca");
- if (!gca) throw std::runtime_error("No gca");
- Py_INCREF(gca);
- PyObject *axis = PyObject_Call(
- gca, detail::_interpreter::get().s_python_empty_tuple, gca_kwargs);
-
- if (!axis) throw std::runtime_error("No axis");
- Py_INCREF(axis);
-
- Py_DECREF(gca);
- Py_DECREF(gca_kwargs);
-
- PyObject *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 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 = get_array(x);
- PyObject* yarray = get_array(y);
- PyObject* zarray = 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>
-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 Numeric>
-bool named_plot(const std::string& name, const std::vector<Numeric>& x, 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* 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 Numeric>
-bool named_semilogx(const std::string& name, const std::vector<Numeric>& x, 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* 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 Numeric>
-bool named_semilogy(const std::string& name, const std::vector<Numeric>& x, 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* 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 Numeric>
-bool named_loglog(const std::string& name, const std::vector<Numeric>& x, 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* 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>
-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 double* xlim()
-{
- detail::_interpreter::get();
-
- PyObject* args = PyTuple_New(0);
- PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_xlim, args);
- PyObject* left = PyTuple_GetItem(res,0);
- PyObject* right = PyTuple_GetItem(res,1);
-
- double* arr = new double[2];
- arr[0] = PyFloat_AsDouble(left);
- arr[1] = PyFloat_AsDouble(right);
-
- if(!res) throw std::runtime_error("Call to xlim() failed.");
-
- Py_DECREF(res);
- return arr;
-}
-
-
-inline double* ylim()
-{
- detail::_interpreter::get();
-
- PyObject* args = PyTuple_New(0);
- PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_ylim, args);
- PyObject* left = PyTuple_GetItem(res,0);
- PyObject* right = PyTuple_GetItem(res,1);
-
- double* arr = new double[2];
- arr[0] = PyFloat_AsDouble(left);
- arr[1] = PyFloat_AsDouble(right);
-
- if(!res) throw std::runtime_error("Call to ylim() failed.");
-
- Py_DECREF(res);
- return arr;
-}
-
-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 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(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* 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)
-{
- detail::_interpreter::get();
-
- PyObject* pyfilename = PyString_FromString(filename.c_str());
-
- PyObject* args = PyTuple_New(1);
- PyTuple_SetItem(args, 0, pyfilename);
-
- PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_save, args);
- if (!res) throw std::runtime_error("Call to save() failed.");
-
- Py_DECREF(args);
- 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
--
GitLab