contourc: Fix work with with vector_2d iterators by introducing vector_2d_view util class

This class could iterates over non-contiguous vector_2d unlike old `vec[0].data()` pointers.

Author: leha-bot

source/matplot/util/common.h

@@ -6,15 +6,16 @@
 #define MATPLOTPLUSPLUS_COMMON_H
 
 #include <algorithm>
+#include <cctype>
 #include <complex>
 #include <functional>
 #include <map>
 #include <matplot/util/concepts.h>
+#include <numeric>
 #include <sstream>
 #include <string>
 #include <string_view>
 #include <vector>
-#include <cctype>
 
 namespace matplot {
     bool iequals(std::string_view str1, std::string_view str2);
@@ -504,6 +505,85 @@ namespace matplot {
 
     double distance(double x1, double y1, double x2, double y2);
 
+    /// \brief Simple read-only 2d view for vector_2d.
+    /// It could iterates over all vector's elements and get value using
+    /// only one index (offset).
+    class vector_2d_view {
+        using vector_2d = matplot::vector_2d;
+        const vector_2d &_vec;
+        const std::size_t _sz;
+
+        /// \brief Helper method for determining the whole array size.
+        /// Required for caching inner vector's size.
+        std::size_t calculate_size(const vector_2d &vec) {
+            return std::accumulate(
+                vec.begin(), vec.end(), (std::size_t)(0),
+                [](auto cnt, const auto &vec) { return cnt + vec.size(); });
+        }
+
+      public:
+        static const double &get_element_from_offset(const vector_2d &vec,
+                                                     std::size_t offset) {
+            std::size_t row_size = vec[0].size();
+            std::size_t cur_row = offset / row_size;
+            std::size_t cur_column = offset % row_size;
+            return vec[cur_row][cur_column];
+        }
+
+        static vector_2d_view from_vector_2d(const vector_2d &vec) {
+            return vector_2d_view(vec);
+        }
+        std::size_t size() const { return _sz; }
+        vector_2d_view(const vector_2d &vec)
+            : _vec(vec), _sz(calculate_size(vec)) {}
+
+        double operator()(std::size_t i, std::size_t j) {
+            return _vec.at(i).at(j);
+        }
+        friend class iterator;
+
+        class iterator {
+            vector_2d_view *const _vec;
+            std::size_t _row_offset;
+            std::size_t _col_offset;
+
+            static bool is_empty_iterator(const iterator &it) {
+                return it._vec == nullptr;
+            }
+            static bool is_end_iterator(const iterator &it) {
+                return is_empty_iterator(it) ||
+                       it._row_offset * it._col_offset >= it._vec->size();
+            }
+
+          public:
+            iterator(vector_2d_view *const vec)
+                : _vec(vec), _row_offset(0), _col_offset(0) {}
+
+            bool operator==(const iterator &it) const {
+                return is_end_iterator(it)
+                           ? is_end_iterator(*this)
+                           : it._vec == _vec && it._row_offset == _row_offset &&
+                                 it._col_offset == _col_offset;
+            }
+
+            auto operator*() const { return (*_vec)(_row_offset, _col_offset); }
+
+            iterator &operator++() {
+                _col_offset++;
+                if (_col_offset >= _vec->_vec.at(_row_offset).size()) {
+                    _col_offset = 0;
+                    _row_offset++;
+                }
+                return *this;
+            }
+
+            // iterator traits
+            using value_type = double;
+        };
+        iterator begin() { return iterator{this}; }
+        iterator end() { return iterator{nullptr}; }
+    };
+
 } // namespace matplot
 
 #endif // MATPLOTPLUSPLUS_COMMON_H

source/matplot/util/contourc.cpp

@@ -1188,13 +1188,16 @@ namespace matplot {
 
     XY QuadContourGenerator::get_point_xy(long point) const {
         assert(point >= 0 && point < _n && "Point index out of bounds.");
-        return XY(_x[0].data()[static_cast<size_t>(point)],
-                  _y[0].data()[static_cast<size_t>(point)]);
+        return XY(vector_2d_view::get_element_from_offset(
+                      _x, static_cast<size_t>(point)),
+                  vector_2d_view::get_element_from_offset(
+                      _y, static_cast<size_t>(point)));
     }
 
     const double &QuadContourGenerator::get_point_z(long point) const {
         assert(point >= 0 && point < _n && "Point index out of bounds.");
-        return _z[0].data()[static_cast<size_t>(point)];
+        return vector_2d_view::get_element_from_offset(
+            _z, static_cast<size_t>(point));
     }
 
     Edge
@@ -1305,9 +1308,10 @@ namespace matplot {
             (_corner_mask
                  ? MASK_EXISTS | MASK_BOUNDARY_S | MASK_BOUNDARY_W
                  : MASK_EXISTS_QUAD | MASK_BOUNDARY_S | MASK_BOUNDARY_W);
-
+        auto z_view = vector_2d_view::from_vector_2d(_z);
         if (two_levels) {
-            const double *z_ptr = _z[0].data();
+
+            auto z_ptr = z_view.begin();
             for (long quad = 0; quad < _n; ++quad, ++z_ptr) {
                 _cache[quad] &= keep_mask;
                 if (*z_ptr > upper_level)
@@ -1316,7 +1320,7 @@ namespace matplot {
                     _cache[quad] |= MASK_Z_LEVEL_1;
             }
         } else {
-            const double *z_ptr = _z[0].data();
+            auto z_ptr = z_view.begin();
             for (long quad = 0; quad < _n; ++quad, ++z_ptr) {
                 _cache[quad] &= keep_mask;
                 if (*z_ptr > lower_level)