added subplots_axes_and_figures/colorbar_placement.cpp

Author: MamoruSobue

CMakeLists.txt

@@ -58,13 +58,13 @@ if(${ADD_DEMO})
   find_package(xtensor 0.24.0 REQUIRED)
   set(CMAKE_CXX_STANDARD 17)
   set(CMAKE_CXX_FLAGS "-Wall -g -DUSE_GUI=${USE_GUI} -DMATPLOTLIB_MINOR_VER_GTE_4=${MATPLOTLIB_MINOR_VER_GTE_4}")
-  # add_subdirectory(gallery/lines_bars_and_markers)
+  add_subdirectory(gallery/lines_bars_and_markers)
   add_subdirectory(gallery/subplots_axes_and_figures)
-  # add_subdirectory(gallery/statistics)
-  # add_subdirectory(gallery/images_contours_and_fields)
-  # add_subdirectory(gallery/shapes_and_collections)
-  # add_subdirectory(gallery/artist_animation)
-  # add_subdirectory(gallery/mplot3d)
+  add_subdirectory(gallery/statistics)
+  add_subdirectory(gallery/images_contours_and_fields)
+  add_subdirectory(gallery/shapes_and_collections)
+  add_subdirectory(gallery/artist_animation)
+  add_subdirectory(gallery/mplot3d)
 endif()
 
 

gallery/shapes_and_collections/patch_collection.cpp

@@ -3,46 +3,50 @@
 
 #include <pybind11/embed.h>
 #include <pybind11/stl.h>
+#include <pybind11/numpy.h>
 
 #include <matplotlibcpp17/pyplot.h>
 #include <matplotlibcpp17/patches.h>
 
-#include <algorithm>
-#include <iostream>
+#include <xtensor/xrandom.hpp>
+
 #include <vector>
 
 namespace py = pybind11;
 using namespace py::literals;
 using namespace std;
-using namespace matplotlibcpp17;
+using namespace matplotlibcpp17::patches;
 using namespace matplotlibcpp17;
 
 int main() {
   py::scoped_interpreter guard{};
   auto plt = matplotlibcpp17::pyplot::import();
   auto [fig, ax] = plt.subplots();
 
+  const int resolution = 50;
   const int N = 3;
-  vector<double> x = {0.7003673, 0.74275081, 0.70928001},
-                 y = {0.56674552, 0.97778533, 0.70633485},
-                 radii = {0.02479158, 0.01578834, 0.06976985};
+  xt::xarray<double> x = xt::random::rand<double>({N});
+  xt::xarray<double> y = xt::random::rand<double>({N});
+  xt::xarray<double> radii = 0.1 * xt::random::rand<double>({N});
   py::list patches; // instead of patches = []
   for (int i = 0; i < N; ++i) {
     const double x1 = x[i], y1 = y[i], r = radii[i];
     auto circle = patches::Circle(Args(py::make_tuple(x1, y1), r));
     patches.append(circle.unwrap());
   }
-  x = {0.71995667, 0.25774443, 0.34154678};
-  y = {0.96876117, 0.6945071, 0.46638326};
-  radii = {0.07028127, 0.05117859, 0.09287414};
-  vector<double> theta1 = {266.3169476, 224.07805212, 234.5563688},
-                 theta2 = {142.85074015, 195.56618216, 287.96383014};
+
+  x = xt::random::rand<double>({N});
+  y = xt::random::rand<double>({N});
+  radii = 0.1 * xt::random::rand<double>({N});
+  xt::xarray<double> theta1 = 360.0 * xt::random::rand<double>({N});
+  xt::xarray<double> theta2 = 360.0 * xt::random::rand<double>({N});
   for (int i = 0; i < N; ++i) {
     const double x1 = x[i], y1 = y[i], r = radii[i], th1 = theta1[i],
                  th2 = theta2[i];
     auto wedge = patches::Wedge(Args(py::make_tuple(x1, y1), r, th1, th2));
     patches.append(wedge.unwrap());
   }
+
   patches.append(
       patches::Wedge(Args(py::make_tuple(0.3, 0.7), 0.1, 0, 360)).unwrap());
   patches.append(patches::Wedge(Args(py::make_tuple(0.7, 0.8), 0.2, 0, 360),
@@ -53,16 +57,30 @@ int main() {
   patches.append(patches::Wedge(Args(py::make_tuple(0.8, 0.3), 0.2, 45, 90),
                                 Kwargs("width"_a = 0.10))
                      .unwrap());
-  // NOTE: Polygon take numpy array as argument, so skip it
-  vector<double> colors_ = {90.63036451, 16.10182093, 74.36211347, 63.29741618,
-                            32.41800177, 92.23765324, 23.72264387, 82.39455709,
-                            75.06071403, 11.37844527};
-  py::list colors = py::cast(colors_);
+
+  for (int i = 0; i < N; ++i) {
+    auto poly__ = xt::random::rand<double>({N, 2});
+    vector<vector<double>> poly_(N);
+    // to vector<vector>>
+    for (int j = 0; j < N; ++j) {
+      poly_[j].resize(2);
+      poly_[j][0] = poly__(j, 0);
+      poly_[j][1] = poly__(j, 1);
+    }
+    // to numpy array
+    auto poly = py::array(py::cast(std::move(poly_)));
+    auto polygon = Polygon(Args(poly, true));
+    patches.append(polygon.unwrap());
+  }
+
+  auto colors__ = 100.0 * xt::random::rand<double>({patches.size()});
+  vector<double> colors_(colors__.begin(), colors__.end());
+  py::array colors = py::cast(colors_);
   auto p = collections::PatchCollection(Args(patches), Kwargs("alpha"_a = 0.4));
   p.set_array(Args(colors));
-  // NOTE: error in python3.6.9 ?
   ax.add_collection(Args(p.unwrap()));
   fig.colorbar(Args(p.unwrap()), Kwargs("ax"_a = ax.unwrap()));
+
 #if USE_GUI
   plt.show();
 #else

gallery/subplots_axes_and_figures/CMakeLists.txt

@@ -2,6 +2,7 @@ add_demo(align_labels_demo align_labels_demo.cpp)
 add_demo(gridspec_multicolumn gridspec_multicolumn.cpp)
 add_demo(multiple_figs_demo multiple_figs_demo.cpp)
 add_demo(colorbar_placement colorbar_placement.cpp)
+add_demo(subplots subplots.cpp)
 
 add_custom_target(subplots_axes_and_figures
   DEPENDS align_labels_demo gridspec_multicolumn multiple_figs_demo colorbar_placement

gallery/subplots_axes_and_figures/colorbar_placement.cpp

@@ -15,8 +15,7 @@ using namespace py::literals;
 using namespace std;
 using namespace matplotlibcpp17;
 
-int main() {
-  py::scoped_interpreter guard{};
+int main1() {
   auto plt = matplotlibcpp17::pyplot::import();
   auto [fig, axs] = plt.subplots(2, 2);
   const vector<string> cmaps = {"RdBu_r", "viridis"};
@@ -30,7 +29,20 @@ int main() {
           x[i][j] = x_(i, j);
       }
       auto &ax = axs[col + row * 2];
-      // auto pcm = ax.pcolormesh(Args(x), Kwargs("cmap"_a = cmaps[col]));
+      auto pcm = ax.pcolormesh(Args(x), Kwargs("cmap"_a = cmaps[col]));
+      fig.colorbar(Args(pcm.unwrap()),
+                   Kwargs("ax"_a = ax.unwrap(), "shrink"_a = 0.6));
     }
   }
+#if USE_GUI
+  plt.show();
+#else
+  plt.savefig(Args("colorbar_placement1.png"));
+#endif
+  return 0;
+}
+
+int main() {
+  py::scoped_interpreter guard{};
+  main1();
 }

gallery/subplots_axes_and_figures/subplots.cpp

@@ -0,0 +1,27 @@
+#include <pybind11/embed.h>
+#include <pybind11/stl.h>
+
+#include <matplotlibcpp17/pyplot.h>
+
+namespace py = pybind11;
+using namespace py::literals;
+using namespace std;
+using namespace matplotlibcpp17;
+
+int main() {
+  py::scoped_interpreter guard{};
+  auto plt = matplotlibcpp17::pyplot::import();
+  {
+    auto [fig, axs] = plt.subplots(3, 1);
+    std::cout << axs.size() << std::endl;
+  }
+  {
+    auto [fig, axs] = plt.subplots(1, 1);
+    std::cout << axs.size() << std::endl;
+  }
+  {
+    auto [fig, axs] = plt.subplots(3, 3);
+    std::cout << axs.size() << std::endl;
+  }
+  return 0;
+}

include/matplotlibcpp17/axes.h

@@ -124,8 +124,9 @@ struct DECL_STRUCT_ATTR Axes : public BaseWrapper {
                         const pybind11::dict &kwargs = pybind11::dict());
 
   // pcolormesh
-  pybind11::object pcolormesh(const pybind11::tuple &args = pybind11::tuple(),
-                              const pybind11::dict &kwargs = pybind11::dict());
+  collections::QuadMesh
+  pcolormesh(const pybind11::tuple &args = pybind11::tuple(),
+             const pybind11::dict &kwargs = pybind11::dict());
 
   // plot
   pybind11::object plot(const pybind11::tuple &args = pybind11::tuple(),
@@ -485,10 +486,10 @@ legend::Legend Axes::legend(const pybind11::tuple &args,
 }
 
 // pcolormesh
-pybind11::object Axes::pcolormesh(const pybind11::tuple &args,
-                                  const pybind11::dict &kwargs) {
+collections::QuadMesh Axes::pcolormesh(const pybind11::tuple &args,
+                                       const pybind11::dict &kwargs) {
   pybind11::object ret = pcolormesh_attr(*args, **kwargs);
-  return ret;
+  return collections::QuadMesh(ret);
 }
 
 // plot

include/matplotlibcpp17/patches.h

@@ -74,6 +74,22 @@ struct DECL_STRUCT_ATTR Wedge : public BaseWrapper {
   pybind11::object wedge_attr;
 };
 
+/**
+ * @brief A wrapper class for matplotlib.patches.Polygon
+ **/
+struct DECL_STRUCT_ATTR Polygon : public BaseWrapper {
+public:
+  Polygon(const pybind11::tuple &args = pybind11::tuple(),
+          const pybind11::dict &kwargs = pybind11::dict()) {
+    polygon_attr =
+        pybind11::module::import("matplotlib.patches").attr("Polygon");
+    self = polygon_attr(*args, **kwargs);
+  }
+
+private:
+  pybind11::object polygon_attr;
+};
+
 } // namespace matplotlibcpp17::patches
 
 #endif /* MATPLOTLIBCPP17_PATCHES_H */

include/matplotlibcpp17/pyplot.h

@@ -300,18 +300,29 @@ PyPlot::subplots(const pybind11::dict &kwargs) {
 
 std::tuple<figure::Figure, std::vector<axes::Axes>>
 PyPlot::subplots(int r, int c, const pybind11::dict &kwargs) {
+  // subplots() returns [][] (if r > 1 && c > 1) else []
+  // return []axes in row-major
+  // NOTE: equal to Axes.flat
   pybind11::tuple args = pybind11::make_tuple(r, c);
   pybind11::list ret = subplots_attr(*args, **kwargs);
   std::vector<axes::Axes> axes;
   pybind11::object fig = ret[0];
   figure::Figure figure(fig);
   if (r == 1 and c == 1) {
-    pybind11::object ax = ret[1];
-    axes.push_back(axes::Axes(ax));
+    // python returns Axes
+    axes.push_back(axes::Axes(ret[1]));
+  } else if (r == 1 or c == 1) {
+    // python returns []Axes
+    pybind11::list axs = ret[1];
+    for (int i = 0; i < r * c; ++i)
+      axes.push_back(axes::Axes(axs[i]));
   } else {
+    // python returns [][]Axes
     pybind11::list axs = ret[1];
     for (pybind11::size_t i = 0; i < axs.size(); ++i) {
-      axes.push_back(axes::Axes(axs[i]));
+      pybind11::list axsi = axs[i];
+      for (unsigned j = 0; j < axsi.size(); ++j)
+        axes.push_back(axes::Axes(axsi[j]));
     }
   }
   return {figure, axes};