plot_surface generalized to typename Matrix instead of nested vectors

Cryoris · Cryoris · commit c7d064015829 · 2019-10-31T12:17:38.000+01:00
diff --git a/examples/surface.cpp b/examples/surface.cpp
@@ -1,12 +1,37 @@
+#include <cmath>
 #include "../matplotlibcpp.h"
+namespace plt = matplotlibcpp;
 
-#include <cmath>
+#ifdef WITH_EIGEN
+  #include <Eigen/Dense>
+#endif
 
-namespace plt = matplotlibcpp;
+typedef std::vector<std::vector<double>> nested_vectors;
 
-int main()
-{
-    std::vector<std::vector<double>> x, y, z;
+template <typename Matrix>
+void get_data(Matrix& x, Matrix& y, Matrix& z) {
+  // check the sizes
+  const unsigned ncols = x.cols(),
+                 nrows = x.rows();
+  assert(ncols == y.cols() && ncols == z.cols());
+  assert(nrows == y.rows() && nrows == z.rows());
+
+  // write data
+  const double a = -5,
+               b = 5;
+  const double col_incr = (b - a) / ncols,
+               row_incr = (b - a) / nrows;
+  for (unsigned i = 0; i < nrows; ++i) {
+    for (unsigned j = 0; j < ncols; ++j) {
+      x(i, j) = i;
+      y(i, j) = j;
+      z(i, j) = ::std::sin(::std::hypot(a + i * col_incr, a + j * row_incr));
+    }
+  }
+}
+
+template <>
+void get_data(nested_vectors& x, nested_vectors& y, nested_vectors& z) {
     for (double i = -5; i <= 5;  i += 0.25) {
         std::vector<double> x_row, y_row, z_row;
         for (double j = -5; j <= 5; j += 0.25) {
@@ -18,7 +43,20 @@ int main()
         y.push_back(y_row);
         z.push_back(z_row);
     }
+}
 
+
+int main() {
+    std::vector<std::vector<double>> x, y, z;
+    get_data(x, y, z);
     plt::plot_surface(x, y, z);
     plt::show();
+
+    #ifdef WITH_EIGEN
+      const unsigned n = 100;  // resolution of hypot function
+      Eigen::MatrixXd X(n,n), Y(n,n), Z(n,n);
+      get_data(X, Y, Z);
+      plt::plot_surface(X, Y,   Z);
+      plt::show();
+    #endif
 }
diff --git a/matplotlibcpp.h b/matplotlibcpp.h
@@ -1,10 +1,11 @@
 //
 // Wishlist:
 // * (WIP) Make work for Eigen Vectors and Matrices
-// * add submodule for our own functions such as spy
 // * export functions in different files for better structure
 // * make plot(y) work with x of unsigned type, or get to the bottom of that
 //   problem at least
+// * errorbar for xerr and yerr
+// * errorbar for yerr of shape (2, N)
 //
 // Changed:
 // * Implement a better way for named_plot, maybe just as additional
@@ -445,7 +446,8 @@ PyObject *get_2darray(const Matrix &A) {
 
 #else // fallback if we don't have numpy: copy every element of the given vector
 
-template <typename Vector> PyObject *get_array(const Vector &v) {
+template <typename Vector>
+PyObject *get_array(const Vector &v) {
   detail::_interpreter::get();
   PyObject *list = PyList_New(v.size());
   for (size_t i = 0; i < v.size(); ++i) {
@@ -460,8 +462,8 @@ namespace detail {
 // @brief Since most of the plot commands require the exact same usage apart
 //        from the call to the correct Python function, we encapsulate this
 // @param pyfunc The matplotlib function to be called with the given arguments
-// @param x The x vector, must support std::vector methods
-// @param y The y vector, must support std::vector methods
+// @param x The x vector
+// @param y The y vector
 // @param s The formatting string for colour, marker and linestyle
 // @param keywords Additional keywords, such as label
 // @return true if plot was successful, false otherwise
@@ -499,19 +501,28 @@ bool plot_base(PyObject *const pyfunc, const VectorX &x, const VectorY &y,
 
 } // namespace detail
 
+// @brief standard plot function supporting the args (x, y, s, keywords)
+// @param x The x vector
+// @param y The y vector
+// @param s The formatting string
+// @param keywords Additional keywords
+// @return true, if successful, false otherwise
 template <typename VectorX, typename VectorY>
 bool plot(const VectorX &x, const VectorY &y, const std::string &s = "",
           const std::map<std::string, std::string> &keywords = {}) {
   return detail::plot_base(detail::_interpreter::get().s_python_function_plot,
                            x, y, s, keywords);
 }
 
+// @brief standard plot function without formatting string, needed if
+//        keywords are given but formatting string is not
 template <typename VectorX, typename VectorY>
 bool plot(const VectorX &x, const VectorY &y,
           const std::map<std::string, std::string> &keywords) {
   return plot(x, y, "", keywords);
 }
 
+// @brief standard plot function if x data is not specified
 template <typename VectorY = std::vector<double>>
 bool plot(const VectorY &y, const std::string &format = "",
           const std::map<std::string, std::string> &keywords = {}) {
@@ -524,6 +535,8 @@ bool plot(const VectorY &y, const std::string &format = "",
   return plot(x, y, format);
 }
 
+// @brief standard plot function if x data is not specified and the formatting
+//        string is missing
 template <typename VectorY = std::vector<double>>
 bool plot(const VectorY &y,
           const std::map<std::string, std::string> &keywords) {
@@ -534,6 +547,7 @@ bool plot(const VectorY &y,
   return plot(x, y, "", keywords);
 }
 
+// @brief loglog plot function, see `plot` for more detail
 template <typename VectorX, typename VectorY>
 bool loglog(const VectorX &x, const VectorY &y, const std::string &s = "",
             const std::map<std::string, std::string> &keywords = {}) {
@@ -567,6 +581,7 @@ bool loglog(const VectorY &y,
   return loglog(x, y, "", keywords);
 }
 
+// @brief semilogx plot function, see `plot` for more detail
 template <typename VectorX, typename VectorY>
 bool semilogx(const VectorX &x, const VectorY &y, const std::string &s = "",
               const std::map<std::string, std::string> &keywords = {}) {
@@ -601,6 +616,7 @@ bool semilogx(const VectorY &y,
   return semilogx(x, y, "", keywords);
 }
 
+// @brief semilogy plot function, see `plot` for more detail
 template <typename VectorX, typename VectorY>
 bool semilogy(const VectorX &x, const VectorY &y, const std::string &s = "",
               const std::map<std::string, std::string> &keywords = {}) {
@@ -635,10 +651,13 @@ bool semilogy(const VectorY &y,
   return semilogy(x, y, "", keywords);
 }
 
-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,
+// @brief plot_surface for datapoints (x_ij, y_ij, z_ij) with i,j = 0..n
+// @param x The x values of the datapoints in a matrix
+// @param y The y values of the datapoints in a matrix
+// @param z The function value of the datapoints in a matrix
+// @param keywords Additional keywords
+template <typename Matrix>
+void plot_surface(const Matrix &x, const Matrix& y, const Matrix& z,
                   const std::map<std::string, std::string> &keywords =
                       std::map<std::string, std::string>()) {
   // We lazily load the modules here the first time this function is called
