Squashed commit of the following:

commit 9047863bb0c1a34bc6473c2dadee720073db631e
Author: Claire Guilbaud <[email protected]>
Date:   Thu Mar 26 15:46:34 2020 +0100

    @enh figure with variadic template args

commit a8a3dd018c14a5e5c98b084f566865ba936c4fec
Author: Claire Guilbaud <[email protected]>
Date:   Thu Mar 26 14:55:36 2020 +0100

    @enh close

commit 6440609657de0f47b6fd4c1a8c213704f2810a4f
Author: Claire Guilbaud <[email protected]>
Date:   Thu Mar 26 13:41:18 2020 +0100

    @enh generic form for scatter

Author: Bidibulke

.gitignore

@@ -33,6 +33,13 @@
 
 # Build
 /examples/build/*
+/contrib/unittests_catch2/build/*
+/contrib/unittests_catch2/cmake-
+/contrib/unittests_catch2/build/*
+/contrib/unittests_catch2/cmake-*
 
 # vim temp files
 *.sw*
+
+# IDE directories
+.idea

contrib/README.md

@@ -35,7 +35,7 @@ Note: platforms folder is necessary to make qt works.
 
 ```cmd
 > cd contrib/unittests_catch2
-> cmake -S -B "./build"
+> cmake -S . -B "./build"
 > cd build
 > make
 > ./run_MatplotlibcppTests

contrib/unittests_catch2/CMakeLists.txt

@@ -76,6 +76,7 @@ target_compile_features(${TU_EXE}
             )
 target_compile_definitions(${TU_EXE}
         PRIVATE
+            USE_VARIADIC_TEMPLATES_ARGS
             CATCH_UNIT_TESTS)
 target_compile_options(${TU_EXE}
             PRIVATE

contrib/unittests_catch2/tu_matplotlibcpp.cpp

@@ -304,15 +304,14 @@ TEST_CASE("matplotlib", "[matplotlibcpp][matplotlib]") {
     REQUIRE_NOTHROW(plt::scatter(x_scatter, y_scatter, 1.0, kw_2));
     plt::show(true);
 
-    // @FIXME
-    //        plt::clf();
-    //        REQUIRE_NOTHROW(plt::scatter(x_scatter, y_scatter, make_tuple(
-    //                "cmap", "twilight",
-    //                "c", z_scatter,
-    //                "s", 46.,
-    //                "marker", "o"
-    //        )));
-    //        plt::show(true);
+    plt::clf();
+    REQUIRE_NOTHROW(plt::scatter(x_scatter, y_scatter, make_tuple(
+        "cmap", "twilight",
+        "c", z_scatter,
+        "s", 46.,
+        "marker", "o"
+        )));
+    plt::show(true);
   }
 
   SECTION("quiver") {
@@ -534,12 +533,25 @@ TEST_CASE("matplotlib_ending", "[matplotlibcpp][matplotlib]") {
   plt::clf();
   plt::named_plot("Courbe", x, y);
   plt::show(true);
-  REQUIRE_NOTHROW(plt::close());
+  REQUIRE_NOTHROW(plt::close(fig_num));
 }
 
 TEST_CASE("matplotlib_figure", "[matplotlibcpp]") {
   plt::ion();
-  REQUIRE_NOTHROW(plt::figure_size(100, 100));
-  plt::show(true);
+
+  SECTION("figure_size") {
+    REQUIRE_NOTHROW(plt::figure_size(100, 100));
+    plt::show(true);
+    REQUIRE_NOTHROW(plt::close());
+  }
+
+  SECTION("figure_template") {
+    vector<double> fsize {6., 4.};
+    REQUIRE_NOTHROW(plt::figure(111, make_tuple(
+        "dpi", 50,
+        "edgecolor", "green",
+        "figsize", fsize
+    )));
+  }
 }
 #endif // CATCH_UNIT_TESTS

matplotlibcpp.h

@@ -468,6 +468,103 @@ PyObject* get_listlist(const std::vector<std::vector<Numeric>>& ll)
 
 } // namespace detail
 
+
+#ifdef USE_VARIADIC_TEMPLATES_ARGS
+
+// ---------------------------------------------
+// Analyse des keywords dans un tuple
+//
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const bool value) {
+    return {key, value ? Py_True : Py_False};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const int value) {
+    return {key, PyLong_FromLong(value)};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const long value) {
+    return {key, PyLong_FromLong(value)};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const double value) {
+    return {key, PyFloat_FromDouble(value)};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const char* value) {
+    return {key, PyString_FromString(value)};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const std::string& value) {
+    PyObject* str_value = PyString_FromString(value.c_str());
+    return {key, str_value};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const std::vector<double>& value) {
+//    PyObject* py_levels = PyList_New(value.size());
+//    for (size_t i = 0; i < value.size(); ++i) {
+//        PyList_SetItem(py_levels, i, PyFloat_FromDouble(value.at(i)));
+//    }
+    return {key, get_array(value)};
+}
+
+std::pair<std::string, PyObject*> analyze_key_value(const char* key, const std::vector<int>& value) {
+    PyObject* args = PyTuple_New(value.size());
+    for(size_t i = 0; i < value.size(); ++i) {
+        PyTuple_SetItem(args, i, PyLong_FromLong(value.at(i)));
+    }
+    return {key, get_array(value)};
+}
+
+template<class Tuple, std::size_t N>
+struct AnalyzeKeywordsHelper {
+    static void analyze_keywords(const Tuple& kw, PyObject* keywords) {
+        AnalyzeKeywordsHelper<Tuple, N-2>::analyze_keywords(kw, keywords);
+        std::string key;
+        PyObject* value;
+        std::tie(key, value) = analyze_key_value(std::get<N-2>(kw), std::get<N-1>(kw));
+        PyDict_SetItemString(keywords, key.c_str(), value);
+        Py_DECREF(value); // @TST
+    }
+};
+
+template<class Tuple>
+struct AnalyzeKeywordsHelper<Tuple, 2> {
+    static void analyze_keywords(const Tuple& kw, PyObject* keywords) {
+        std::string key;
+        PyObject* value;
+        std::tie(key, value) = analyze_key_value(std::get<0>(kw), std::get<1>(kw));
+        PyDict_SetItemString(keywords, key.c_str(), value);
+        Py_DECREF(value); // @TST
+    }
+};
+
+template<class... Args>
+PyObject* analyze_keywords(const std::tuple<Args...>& kw) {
+    // Inutile de vérifier que la longueur du tuple est un multiple de 2,
+    // car comme on avance de 2 en 2, l'instanciation du template ne peut pas se faire pour
+    // un tuple qui n'a pas un nombre pair d'items.
+    PyObject* keywords = PyDict_New();
+    AnalyzeKeywordsHelper<decltype(kw), sizeof...(Args)>::analyze_keywords(kw, keywords);
+    return keywords;
+}
+
+// ----------
+// Identity type conversion to PyObject* (for functions `figure(Identity, tuple<Args...>&)` and `close(Identity)`)
+//
+PyObject* get_pyobject_from(const int value) {
+    return PyLong_FromLong(value);
+}
+
+PyObject* get_pyobject_from(const char* value) {
+    return PyString_FromString(value);
+}
+
+PyObject* get_pyobject_from(const std::string& value) {
+    return PyString_FromString(value.c_str());
+}
+#endif // USE_VARIADIC_TEMPLATES_ARGS
+
+
 /// 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
@@ -894,36 +991,58 @@ void imshow(const cv::Mat &image, const std::map<std::string, std::string> &keyw
 #endif // WITHOUT_NUMPY
 
 template<typename NumericX, typename NumericY>
-bool scatter(const std::vector<NumericX>& x,
+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 = {})
+             PyObject* kwargs)
 {
-    detail::_interpreter::get();
+  detail::_interpreter::get();
+	    
+  assert(x.size() == y.size());
 
-    assert(x.size() == y.size());
+  PyObject* xarray = get_array(x);
+  PyObject* yarray = get_array(y);
 
-    PyObject* xarray = detail::get_array(x);
-    PyObject* yarray = detail::get_array(y);
+  PyObject* args = PyTuple_New(2);
+  PyTuple_SetItem(args, 0, xarray);
+  PyTuple_SetItem(args, 1, yarray);
+
+  PyObject* res = PyObject_Call(detail::_interpreter::get().s_python_function_scatter, args, kwargs);
 
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+
+  if(!res) {
+    throw std::runtime_error("Call to scatter(x, y [, marker]) failed.");
+  }
+
+  Py_DECREF(res);
+
+  return res;
+}
+
+// generic form
+template <typename Numeric, class... Args>
+inline bool scatter(const std::vector<Numeric>& x, const std::vector<Numeric>& y, const std::tuple<Args...>& keywords)
+{
+  PyObject* kwargs = analyze_keywords(keywords);
+  return __scatter(x, y, kwargs);
+}
+
+// specialized form
+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 = {})
+{
     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;
+    return __scatter(x, y, kwargs);
 }
 
 template<typename Numeric>
@@ -1523,6 +1642,36 @@ inline long figure(long number = -1)
     return figureNumber;
 }
 
+template <typename Identity, class... Args>
+inline Identity figure(Identity number, const std::tuple<Args...>& keywords)
+{
+  // Identity est de type int ou string
+  PyObject* args = PyTuple_New(1);
+  PyTuple_SetItem(args, 0, get_pyobject_from(number));
+
+  PyObject* kwargs = analyze_keywords(keywords);
+
+  PyObject* res = nullptr;
+  res = PyObject_Call(detail::_interpreter::get().s_python_function_figure, args, kwargs);
+
+  Py_DECREF(args);
+  Py_DECREF(kwargs);
+
+  if(!res) {
+    PyErr_Print();
+    throw std::runtime_error("Call to pyplot.figure(num) failed.");
+  }
+
+  PyObject* num = PyObject_GetAttrString(res, "number");
+  if (!num) throw std::runtime_error("Could not get number attribute of figure object");
+  auto figureNumber = static_cast<Identity>(PyLong_AsLong(num));
+
+  Py_DECREF(num);
+  Py_DECREF(res);
+
+  return figureNumber;
+}
+
 inline bool fignum_exists(long number)
 {
     detail::_interpreter::get();
@@ -2048,6 +2197,23 @@ inline void close()
     Py_DECREF(res);
 }
 
+template <typename Identity>
+inline void close(Identity num)
+{
+  PyObject* args = PyTuple_New(1);
+  PyTuple_SetItem(args, 0, get_pyobject_from(num));
+
+  PyObject* res = PyObject_CallObject(detail::_interpreter::get().s_python_function_close, args);
+
+  Py_DECREF(args);
+
+  if (!res) {
+    throw std::runtime_error("Call to close(num) failed.");
+  }
+
+  Py_DECREF(res);
+}
+
 inline void xkcd() {
     detail::_interpreter::get();