added support for 2D std-vector and 2D std-arrays; added imshow example; code refactoring

Author: muralivnv

README.md

@@ -78,6 +78,15 @@ The macro `_p` captures variable name and expands into ("variable_name", variabl
 
 **Note**: Every container that is passed to python for plotting will be converted into an numpy array. This means fancy array slicing and array manipulations is possible. Just treat data as if it is originated in python with numpy.
 
+Currently supports
+* 1D std vector
+* 1D std array
+* 2D std vector
+* 2D std array
+* Eigen containers
+
+For information on how to include support for custom containers read section [custom container support](https://github.com/muralivnv/Cppyplot#custom-container-support). 
+
 ## How-it-works
 Plot object `cppyplot` passes all the commands and containers to a python server (which is spawned automatically when the `cppyplot` object is created) using ZeroMQ. The spawned python server uses [asteval](https://anaconda.org/conda-forge/asteval) library to parse the passed commands. This means any command that can be used in python can be written on C++ side.     
 
@@ -96,63 +105,69 @@ As the library uses zmq, link the source file which uses cppyplot.hpp with the l
 ## Custom Container Support
 By defining 3 helper functions, any c++ container can be adapted to pass onto python side. 
 
-#### Define `size_str`
-Define function to transform container size (total number of elems) into string object. See example down below where `size_str` function was defined for containers of type `std::array` and `std::vector`.
+Define the following functions at the end of the **cppyplot_container_support.h** located in the include folder.
+
+#### Define `container_size`
+Define function to return container size (total number of elems). See example down below where `container_size` function was defined for containers of type `std::array` and `std::vector`.
 
 ```cpp
 // 1D-array
-template<typename T, std::size_t>
-std::string size_str(const std::array<T>& container)
-{
-  return std::to_string(container.size());
-}
+template<typename T, std::size_t N>
+inline std::size_t container_size(const std::array<T, N>& data)
+{ (void)data; return N; }
 
 // 2D-vector
 template<typename T>
-std::string size_str(const std::vector<std::vector<T>>& container)
-{
-  return std::to_string(container.size()*container[0].size());
-}
+inline std::size_t container_size(const std::vector<std::vector<T>>& data)
+{ return data.size()*data[0].size(); }
 ```
 
-Follow the link, [Eigen_Support](https://github.com/muralivnv/Cppyplot/blob/master/include/cppyplot.hpp#L171) to look at Eigen container support.  
-**Note**: This function need to be defined before the class defintion `cppyplot` in file `cppyplot.hpp`.  
-
-#### Define `shape_str`
-Define function to transform container shape (number of row, number of cols) into string object. See example down below where `shape_str` function was defined for containers of type `std::vector` and `std::vector<std::vector>`. This shape information will be used to reshape the array on python side using numpy.
+#### Define `container_shape`
+Define function to return container shape (number of row, number of cols). See example down below where `container_shape` function was defined for containers of type `std::vector` and `std::vector<std::vector>`. This shape information will be used to reshape the array on python side using numpy.
 
 ```cpp
 // 1D-vector
 template<typename T>
-std::string shape_str(const std::vector<T>& container)
-{
-  return "(" + std::to_string(container.size()) + ",)";
-} // returns "(n_rows,)"
+inline std::array<std::size_t,1> container_shape(const std::vector<T>& data)
+{ return std::array<std::size_t, 1>{data.size()}; }
 
 // 2D-vector
 template<typename T>
-std::string shape_str(const std::vector<std::vector<T>>& container)
-{
-  return "(" + std::to_string(container.size()) + "," + container.front().size() + ")";
-} // returns "(n_rows, n_cols)"
+inline std::array<std::size_t, 2> container_shape(const std::vector<std::vector<T>>& data)
+{ return std::array<std::size_t, 2>{data.size(), data[0].size()}; }
 ```
 
-#### Define `void_ptr`
-The underlying zmq publisher requires pointer to the raw buffer inside the container to pass the data to python server. For that purpose define function `void_ptr` to extract data pointer and cast it into `(void*)`. See example down below which shows how to extract raw pointers for containers of type `std::vector` and `std::array`.
+#### Define `fill_zmq_buffer`
+The underlying zmq buffer requires either copying data to its buffer or pointing the zmq buffer to the container buffer. 
+
+Use the technique down below to point zmq buffer to the container buffer if the data inside the container is stored in one single continuous buffer. See example down below, where `fill_zmq_buffer` is defined for 1D-vector. As the internal vector buffer is stored in one continuous buffer, we can just point zmq buffer to vector buffer with custom dealloc function.
 
 ```cpp
 // 1D-vector
 template<typename T>
-void* void_ptr(const std::vector<T>& vec)
+inline void fill_zmq_buffer(const std::vector<T>& data, zmq::message_t& buffer)
 {
-  return (void*)vec.data();
+  buffer.rebuild((void*)data.data(), sizeof(T)*data.size(), custom_dealloc, nullptr);
 }
+```
 
-// 1D-array
-template<typename T, std::size_t N>
-void* void_ptr(const std::array<T, N>& arr)
+If the buffer insider custom container is not stored in one single continuous buffer(for example `vector<vector<float>>`) then use mempcy to copy data.
+
+```cpp
+// 2D vector
+// this uses mempcpy, there will be a runtime overhead
+template<typename T, std::size_t N, std::size_t M>
+inline void fill_zmq_buffer(const std::array<std::array<T, M>, N>& data, zmq::message_t& buffer)
 {
-  return (void*)arr.data();
+  buffer.rebuild(sizeof(T)*N*M);
+  char * ptr = static_cast<char*>(buffer.data());
+
+  std::size_t offset = 0u;
+  size_t n_bytes = sizeof(T)*M;
+  for (std::size_t i = 0u; i < N; i++)
+  {
+    memcpy(ptr+offset, data[i].data(), n_bytes);
+    offset += n_bytes;
+  }
 }
-
 ```

examples/for_matplotlib/container_2d_imshow.cpp

@@ -0,0 +1,42 @@
+#include "../../include/cppyplot.hpp"
+
+#include <cmath>
+#include <algorithm>
+#include <random>
+
+int main()
+{
+  std::random_device seed;
+  std::mt19937 gen(seed());
+  std::normal_distribution<float> norm(0.0F, 10.0F);
+ 
+  std::vector<std::vector<float>> image_vec(50, std::vector<float>(60));
+  std::array<std::array<float, 100>, 100> image_arr;
+  for (auto& row: image_vec)
+  {
+    std::iota(row.begin(), row.end(), 1.0F);
+  }
+  for (auto& row : image_arr)
+  {
+    for (auto& elem : row)
+    { elem = norm(gen); }
+  }
+
+  Cppyplot::cppyplot pyp;
+
+  pyp.raw(R"pyp(
+  plt.figure(figsize=(6,5))
+  plt.imshow(image_vec)
+  plt.title("2D-C++ std vector")
+  plt.show(block=False)
+  plt.figure(figsize=(6,5))
+  plt.imshow(image_arr)
+  plt.title("2D-C++ std array")
+  plt.show(block=True)
+  )pyp");
+  pyp.data_args(_p(image_vec), _p(image_arr));
+
+  std::cout << "Good bye ...";
+  
+  return EXIT_SUCCESS;
+}

include/cppyplot.hpp

@@ -55,143 +55,15 @@ constexpr decltype(auto) compile_time_str(const char(&str)[N])
 
 namespace Cppyplot
 {
-  
-/* ZMQ requires custom dealloc function for zero-copy */
-void custom_dealloc(void* data, void* hint)
-{
-  (void)data;
-  (void)hint; 
-  return; 
-}
 
 // utility function for raw string literal parsing
 std::string dedent_string(const std::string_view raw_str);
 
 template<typename T>
-struct ValType{
-  const static std::size_t elem_size = 0u;
-  inline const static std::string typestr{"0"};
-};
-
-template<>
-struct ValType<char>{
-  const static std::size_t elem_size = sizeof(char);
-  inline const static std::string typestr{"c"};
-};
-
-template<>
-struct ValType<signed char>{
-  const static std::size_t elem_size = sizeof(signed char);
-  inline const static std::string typestr{"b"};
-};
-
-template<>
-struct ValType<unsigned char>{
-  const static std::size_t elem_size = sizeof(unsigned char);
-  inline const static std::string typestr{"B"};
-};
-
-template<>
-struct ValType<short>{
-  const static std::size_t elem_size = sizeof(short);
-  inline const static std::string typestr{"h"};
-};
-
-template<>
-struct ValType<unsigned short>{
-  const static std::size_t elem_size = sizeof(unsigned short);
-  inline const static std::string typestr{"H"};
-};
-
-template<>
-struct ValType<int>{
-  const static std::size_t elem_size = sizeof(int);
-  inline const static std::string typestr{"i"};
-};
+std::string shape_str(const T& shape);
 
-template<>
-struct ValType<unsigned int>{
-  const static std::size_t elem_size = sizeof(unsigned int);
-  inline const static std::string typestr{"I"};
-};
-
-template<>
-struct ValType<long>{
-  const static std::size_t elem_size = sizeof(long);
-  inline const static std::string typestr{"l"};
-};
-
-template<>
-struct ValType<unsigned long>{
-  const static std::size_t elem_size = sizeof(unsigned long);
-  inline const static std::string typestr{"L"};
-};
-
-template<>
-struct ValType<long long>{
-  const static std::size_t elem_size = sizeof(long long);
-  inline const static std::string typestr{"q"};
-};
-
-template<>
-struct ValType<unsigned long long>{
-  const static std::size_t elem_size = sizeof(unsigned long long);
-  inline const static std::string typestr{"Q"};
-};
-
-template<>
-struct ValType<float>{
-  const static std::size_t elem_size = sizeof(float);
-  inline const static std::string typestr{"f"};
-};
-
-template<>
-struct ValType<double>{
-  const static std::size_t elem_size = sizeof(double);
-  inline const static std::string typestr{"d"};
-};
-
-
-template<typename T>
-inline std::string shape_str(const std::vector<T>& data)
-{
-  return "(" + std::to_string(data.size()) +",)";
-}
-
-template<typename T>
-inline std::string size_str(const std::vector<T>& data)
-{
-   return std::to_string(data.size());
-}
-
-template<typename T>
-inline void* void_ptr(const std::vector<T>& data) noexcept
-{
-  return (void*)data.data();
-}
-
-
-#if defined (EIGEN_AVAILABLE)
-/*Reference: https://eigen.tuxfamily.org/dox/TopicFunctionTakingEigenTypes.html */
-template<typename Derived>
-inline std::string shape_str(const Eigen::EigenBase<Derived>& eigen_container)
-{
-  return "(" + std::to_string(eigen_container.rows()) + "," + std::to_string(eigen_container.cols()) +")";
-}
-
-template<typename Derived>
-inline std::string size_str(const Eigen::EigenBase<Derived>& eigen_container)
-{
-  return std::to_string(eigen_container.size());
-}
-
-template<typename Derived>
-inline void* void_ptr(const Eigen::EigenBase<Derived>& eigen_container)
-{
-  return (void*)eigen_container.derived().data();
-}
-
-#endif 
+#include "cppyplot_types.h"
+#include "cppyplot_container_support.h"
 
 class cppyplot{
   private:
@@ -240,38 +112,36 @@ class cppyplot{
     template<typename T>
     inline std::string create_header(const std::string& key, const T& cont) noexcept
     {
-      using elem_type = typename T::value_type;
+      auto elem_type = get_ValType(cont);
       std::string header{"data|"};
 
       // variable name
       header += key;
       header.append("|");
 
       // container element type (float or int or ...)
-      header += ValType<elem_type>::typestr;
+      header += std::string{decltype(elem_type)::typestr};
       header.append("|");
 
       // total number of elements in the container
-      header += size_str(cont);
+      header += std::to_string(container_size(cont));
       header.append("|");
 
       // shape of the container 
-      header += shape_str(cont);
+      header += shape_str(container_shape(cont));
 
       return header;
     }
 
     template <typename T>
     void send_container(const std::string& key, const T& cont)
     {
-      using elem_type = typename T::value_type;
-
       std::string data_header{create_header(key, cont)};
       zmq::message_t msg(data_header.c_str(), data_header.length());
       socket_.send(msg, zmq::send_flags::none);
 
-      zmq::message_t payload(void_ptr(cont), ValType<elem_type>::elem_size*cont.size(), 
-                              custom_dealloc, nullptr);
+      zmq::message_t payload;
+      fill_zmq_buffer(cont, payload);
       socket_.send(payload, zmq::send_flags::none);
     }
 
@@ -352,6 +222,21 @@ std::string dedent_string(const std::string_view raw_str)
   }
 }
 
+
+template<typename T>
+std::string shape_str(const T& shape)
+{
+  std::string out_str("(");
+  for (auto size : shape)
+  {
+    out_str.append(std::to_string(size));
+    out_str.append(",");
+  }
+  out_str.append(")");
+
+  return out_str;
+}
+
 }
 
 #endif