From 2bdc7860c1a945abc4e9061e3149c7510c11c306 Mon Sep 17 00:00:00 2001
From: Elliott Sales de Andrade <quantum.analyst@gmail.com>
Date: Mon, 23 Jun 2025 20:13:36 -0400
Subject: [PATCH 1/5] Make path-to-string conversion a little safer

... by replacing double pointers by fixed-size `std::array`, or a return
`tuple`. With gcc (and optimization enabled?), this has no effect on
code size, but gives compile-time (and better runtime) checks that there
are no out-of-bounds access.
---
 src/_path.h           | 52 +++++++++++++++++++++----------------------
 src/_path_wrapper.cpp |  7 +-----
 2 files changed, 26 insertions(+), 33 deletions(-)

diff --git a/src/_path.h b/src/_path.h
index c03703776760..6f315f2109e1 100644
--- a/src/_path.h
+++ b/src/_path.h
@@ -3,12 +3,12 @@
 #ifndef MPL_PATH_H
 #define MPL_PATH_H
 
-#include <limits>
-#include <math.h>
-#include <vector>
-#include <cmath>
 #include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
 #include <string>
+#include <vector>
 
 #include "agg_conv_contour.h"
 #include "agg_conv_curve.h"
@@ -1051,15 +1051,14 @@ void cleanup_path(PathIterator &path,
 void quad2cubic(double x0, double y0,
                 double x1, double y1,
                 double x2, double y2,
-                double *outx, double *outy)
+                std::array<double, 3> &outx, std::array<double, 3> &outy)
 {
-
-    outx[0] = x0 + 2./3. * (x1 - x0);
-    outy[0] = y0 + 2./3. * (y1 - y0);
-    outx[1] = outx[0] + 1./3. * (x2 - x0);
-    outy[1] = outy[0] + 1./3. * (y2 - y0);
-    outx[2] = x2;
-    outy[2] = y2;
+    std::get<0>(outx) = x0 + 2./3. * (x1 - x0);
+    std::get<0>(outy) = y0 + 2./3. * (y1 - y0);
+    std::get<1>(outx) = std::get<0>(outx) + 1./3. * (x2 - x0);
+    std::get<1>(outy) = std::get<0>(outy) + 1./3. * (y2 - y0);
+    std::get<2>(outx) = x2;
+    std::get<2>(outy) = y2;
 }
 
 
@@ -1104,27 +1103,27 @@ void __add_number(double val, char format_code, int precision,
 template <class PathIterator>
 bool __convert_to_string(PathIterator &path,
                          int precision,
-                         char **codes,
+                         const std::array<std::string, 5> &codes,
                          bool postfix,
                          std::string& buffer)
 {
     const char format_code = 'f';
 
-    double x[3];
-    double y[3];
+    std::array<double, 3> x;
+    std::array<double, 3> y;
     double last_x = 0.0;
     double last_y = 0.0;
 
     unsigned code;
 
-    while ((code = path.vertex(&x[0], &y[0])) != agg::path_cmd_stop) {
+    while ((code = path.vertex(&std::get<0>(x), &std::get<0>(y))) != agg::path_cmd_stop) {
         if (code == CLOSEPOLY) {
-            buffer += codes[4];
+            buffer += std::get<4>(codes);
         } else if (code < 5) {
             size_t size = NUM_VERTICES[code];
 
             for (size_t i = 1; i < size; ++i) {
-                unsigned subcode = path.vertex(&x[i], &y[i]);
+                unsigned subcode = path.vertex(&x.at(i), &y.at(i));
                 if (subcode != code) {
                     return false;
                 }
@@ -1133,29 +1132,29 @@ bool __convert_to_string(PathIterator &path,
             /* For formats that don't support quad curves, convert to
                cubic curves */
             if (code == CURVE3 && codes[code - 1][0] == '\0') {
-                quad2cubic(last_x, last_y, x[0], y[0], x[1], y[1], x, y);
+                quad2cubic(last_x, last_y, x.at(0), y.at(0), x.at(1), y.at(1), x, y);
                 code++;
                 size = 3;
             }
 
             if (!postfix) {
-                buffer += codes[code - 1];
+                buffer += codes.at(code - 1);
                 buffer += ' ';
             }
 
             for (size_t i = 0; i < size; ++i) {
-                __add_number(x[i], format_code, precision, buffer);
+                __add_number(x.at(i), format_code, precision, buffer);
                 buffer += ' ';
-                __add_number(y[i], format_code, precision, buffer);
+                __add_number(y.at(i), format_code, precision, buffer);
                 buffer += ' ';
             }
 
             if (postfix) {
-                buffer += codes[code - 1];
+                buffer += codes.at(code - 1);
             }
 
-            last_x = x[size - 1];
-            last_y = y[size - 1];
+            last_x = x.at(size - 1);
+            last_y = y.at(size - 1);
         } else {
             // Unknown code value
             return false;
@@ -1174,7 +1173,7 @@ bool convert_to_string(PathIterator &path,
                        bool simplify,
                        SketchParams sketch_params,
                        int precision,
-                       char **codes,
+                       const std::array<std::string, 5> &codes,
                        bool postfix,
                        std::string& buffer)
 {
@@ -1211,7 +1210,6 @@ bool convert_to_string(PathIterator &path,
         sketch_t sketch(curve, sketch_params.scale, sketch_params.length, sketch_params.randomness);
         return __convert_to_string(sketch, precision, codes, postfix, buffer);
     }
-
 }
 
 template<class T>
diff --git a/src/_path_wrapper.cpp b/src/_path_wrapper.cpp
index 2a297e49ac92..6375351cb52e 100644
--- a/src/_path_wrapper.cpp
+++ b/src/_path_wrapper.cpp
@@ -252,16 +252,11 @@ static py::object
 Py_convert_to_string(mpl::PathIterator path, agg::trans_affine trans,
                      agg::rect_d cliprect, std::optional<bool> simplify,
                      SketchParams sketch, int precision,
-                     std::array<std::string, 5> codes_obj, bool postfix)
+                     const std::array<std::string, 5> &codes, bool postfix)
 {
-    char *codes[5];
     std::string buffer;
     bool status;
 
-    for (auto i = 0; i < 5; ++i) {
-        codes[i] = const_cast<char *>(codes_obj[i].c_str());
-    }
-
     if (!simplify.has_value()) {
         simplify = path.should_simplify();
     }

From 6d5dd9a5947058644603fafd2d67bc952ec41db8 Mon Sep 17 00:00:00 2001
From: Elliott Sales de Andrade <quantum.analyst@gmail.com>
Date: Mon, 23 Jun 2025 20:21:35 -0400
Subject: [PATCH 2/5] Make path clipping a bit safer

... by avoiding double pointers.

From 5ba391b8723753b06a55a6e507309445e79accb8 Mon Sep 17 00:00:00 2001
From: Elliott Sales de Andrade <quantum.analyst@gmail.com>
Date: Tue, 9 Sep 2025 03:58:15 -0400
Subject: [PATCH 3/5] MNT: Fix type of _finalize_polygon::closed_only

It is `bool` for the Python wrapper, while internally `int`, but can be
`bool` consistently.

Also mark it as `inline` since it's used in a template and the compiler
warns about a possible ODR violation (which isn't a problem since it's
only used in one file.)
---
 src/_path.h | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/_path.h b/src/_path.h
index 6f315f2109e1..dc9058535f5f 100644
--- a/src/_path.h
+++ b/src/_path.h
@@ -43,7 +43,8 @@ struct XY
 
 typedef std::vector<XY> Polygon;
 
-void _finalize_polygon(std::vector<Polygon> &result, int closed_only)
+inline void
+_finalize_polygon(std::vector<Polygon> &result, bool closed_only)
 {
     if (result.size() == 0) {
         return;
@@ -691,12 +692,12 @@ clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vecto
 
         // Empty polygons aren't very useful, so skip them
         if (polygon1.size()) {
-            _finalize_polygon(results, 1);
+            _finalize_polygon(results, true);
             results.push_back(polygon1);
         }
     } while (code != agg::path_cmd_stop);
 
-    _finalize_polygon(results, 1);
+    _finalize_polygon(results, true);
 }
 
 template <class VerticesArray, class ResultArray>
@@ -956,7 +957,7 @@ void convert_path_to_polygons(PathIterator &path,
                               agg::trans_affine &trans,
                               double width,
                               double height,
-                              int closed_only,
+                              bool closed_only,
                               std::vector<Polygon> &result)
 {
     typedef agg::conv_transform<mpl::PathIterator> transformed_path_t;
@@ -980,7 +981,7 @@ void convert_path_to_polygons(PathIterator &path,
 
     while ((code = curve.vertex(&x, &y)) != agg::path_cmd_stop) {
         if ((code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly) {
-            _finalize_polygon(result, 1);
+            _finalize_polygon(result, true);
             polygon = &result.emplace_back();
         } else {
             if (code == agg::path_cmd_move_to) {

From 3f920bf45785fc7a854b82f19ec0fa774dd2f2da Mon Sep 17 00:00:00 2001
From: Elliott Sales de Andrade <quantum.analyst@gmail.com>
Date: Tue, 9 Sep 2025 04:56:54 -0400
Subject: [PATCH 4/5] path: Simplify extent_limits implementation a bit

By using the existing `XY` type to replace x/y pairs, and taking
advantage of struct methods.
---
 src/_path.h           | 70 ++++++++++++++++++++-----------------------
 src/_path_wrapper.cpp | 12 ++++----
 2 files changed, 39 insertions(+), 43 deletions(-)

diff --git a/src/_path.h b/src/_path.h
index dc9058535f5f..de6749e21995 100644
--- a/src/_path.h
+++ b/src/_path.h
@@ -312,43 +312,39 @@ inline bool point_on_path(
 
 struct extent_limits
 {
-    double x0;
-    double y0;
-    double x1;
-    double y1;
-    double xm;
-    double ym;
-};
+    XY start;
+    XY end;
+    /* minpos is the minimum positive values in the data; used by log scaling. */
+    XY minpos;
 
-void reset_limits(extent_limits &e)
-{
-    e.x0 = std::numeric_limits<double>::infinity();
-    e.y0 = std::numeric_limits<double>::infinity();
-    e.x1 = -std::numeric_limits<double>::infinity();
-    e.y1 = -std::numeric_limits<double>::infinity();
-    /* xm and ym are the minimum positive values in the data, used
-       by log scaling */
-    e.xm = std::numeric_limits<double>::infinity();
-    e.ym = std::numeric_limits<double>::infinity();
-}
+    extent_limits() : start{0,0}, end{0,0}, minpos{0,0} {
+        reset();
+    }
 
-inline void update_limits(double x, double y, extent_limits &e)
-{
-    if (x < e.x0)
-        e.x0 = x;
-    if (y < e.y0)
-        e.y0 = y;
-    if (x > e.x1)
-        e.x1 = x;
-    if (y > e.y1)
-        e.y1 = y;
-    /* xm and ym are the minimum positive values in the data, used
-       by log scaling */
-    if (x > 0.0 && x < e.xm)
-        e.xm = x;
-    if (y > 0.0 && y < e.ym)
-        e.ym = y;
-}
+    void reset()
+    {
+        start.x = std::numeric_limits<double>::infinity();
+        start.y = std::numeric_limits<double>::infinity();
+        end.x = -std::numeric_limits<double>::infinity();
+        end.y = -std::numeric_limits<double>::infinity();
+        minpos.x = std::numeric_limits<double>::infinity();
+        minpos.y = std::numeric_limits<double>::infinity();
+    }
+
+    void update(double x, double y)
+    {
+        start.x = std::min(start.x, x);
+        start.y = std::min(start.y, y);
+        end.x = std::max(end.x, x);
+        end.y = std::max(end.y, y);
+        if (x > 0.0) {
+            minpos.x = std::min(minpos.x, x);
+        }
+        if (y > 0.0) {
+            minpos.y = std::min(minpos.y, y);
+        }
+    }
+};
 
 template <class PathIterator>
 void update_path_extents(PathIterator &path, agg::trans_affine &trans, extent_limits &extents)
@@ -367,7 +363,7 @@ void update_path_extents(PathIterator &path, agg::trans_affine &trans, extent_li
         if ((code & agg::path_cmd_end_poly) == agg::path_cmd_end_poly) {
             continue;
         }
-        update_limits(x, y, extents);
+        extents.update(x, y);
     }
 }
 
@@ -390,7 +386,7 @@ void get_path_collection_extents(agg::trans_affine &master_transform,
 
     agg::trans_affine trans;
 
-    reset_limits(extent);
+    extent.reset();
 
     for (auto i = 0; i < N; ++i) {
         typename PathGenerator::path_iterator path(paths(i % Npaths));
diff --git a/src/_path_wrapper.cpp b/src/_path_wrapper.cpp
index 6375351cb52e..fd80b02b85ae 100644
--- a/src/_path_wrapper.cpp
+++ b/src/_path_wrapper.cpp
@@ -68,15 +68,15 @@ Py_get_path_collection_extents(agg::trans_affine master_transform,
 
     py::ssize_t dims[] = { 2, 2 };
     py::array_t<double> extents(dims);
-    *extents.mutable_data(0, 0) = e.x0;
-    *extents.mutable_data(0, 1) = e.y0;
-    *extents.mutable_data(1, 0) = e.x1;
-    *extents.mutable_data(1, 1) = e.y1;
+    *extents.mutable_data(0, 0) = e.start.x;
+    *extents.mutable_data(0, 1) = e.start.y;
+    *extents.mutable_data(1, 0) = e.end.x;
+    *extents.mutable_data(1, 1) = e.end.y;
 
     py::ssize_t minposdims[] = { 2 };
     py::array_t<double> minpos(minposdims);
-    *minpos.mutable_data(0) = e.xm;
-    *minpos.mutable_data(1) = e.ym;
+    *minpos.mutable_data(0) = e.minpos.x;
+    *minpos.mutable_data(1) = e.minpos.y;
 
     return py::make_tuple(extents, minpos);
 }

From b64f3d74f413508ca2cb7babd23f7c7081ac24d8 Mon Sep 17 00:00:00 2001
From: Elliott Sales de Andrade <quantum.analyst@gmail.com>
Date: Tue, 9 Sep 2025 05:15:31 -0400
Subject: [PATCH 5/5] path: Simplify parts of clip_path_to_rect

Use `XY` type to shorten internals, and `agg::rect_d::normalize` to
shorten initialization.
---
 src/_path.h           | 93 ++++++++++++++++++++-----------------------
 src/_path_wrapper.cpp |  4 +-
 2 files changed, 44 insertions(+), 53 deletions(-)

diff --git a/src/_path.h b/src/_path.h
index de6749e21995..226d60231682 100644
--- a/src/_path.h
+++ b/src/_path.h
@@ -26,6 +26,8 @@ struct XY
     double x;
     double y;
 
+    XY() : x(0), y(0) {}
+
     XY(double x_, double y_) : x(x_), y(y_)
     {
     }
@@ -521,12 +523,14 @@ struct bisectx
     {
     }
 
-    inline void bisect(double sx, double sy, double px, double py, double *bx, double *by) const
+    inline XY bisect(const XY s, const XY p) const
     {
-        *bx = m_x;
-        double dx = px - sx;
-        double dy = py - sy;
-        *by = sy + dy * ((m_x - sx) / dx);
+        double dx = p.x - s.x;
+        double dy = p.y - s.y;
+        return {
+            m_x,
+            s.y + dy * ((m_x - s.x) / dx),
+        };
     }
 };
 
@@ -536,9 +540,9 @@ struct xlt : public bisectx
     {
     }
 
-    inline bool is_inside(double x, double y) const
+    inline bool is_inside(const XY point) const
     {
-        return x <= m_x;
+        return point.x <= m_x;
     }
 };
 
@@ -548,9 +552,9 @@ struct xgt : public bisectx
     {
     }
 
-    inline bool is_inside(double x, double y) const
+    inline bool is_inside(const XY point) const
     {
-        return x >= m_x;
+        return point.x >= m_x;
     }
 };
 
@@ -562,12 +566,14 @@ struct bisecty
     {
     }
 
-    inline void bisect(double sx, double sy, double px, double py, double *bx, double *by) const
+    inline XY bisect(const XY s, const XY p) const
     {
-        *by = m_y;
-        double dx = px - sx;
-        double dy = py - sy;
-        *bx = sx + dx * ((m_y - sy) / dy);
+        double dx = p.x - s.x;
+        double dy = p.y - s.y;
+        return {
+            s.x + dx * ((m_y - s.y) / dy),
+            m_y,
+        };
     }
 };
 
@@ -577,9 +583,9 @@ struct ylt : public bisecty
     {
     }
 
-    inline bool is_inside(double x, double y) const
+    inline bool is_inside(const XY point) const
     {
-        return y <= m_y;
+        return point.y <= m_y;
     }
 };
 
@@ -589,9 +595,9 @@ struct ygt : public bisecty
     {
     }
 
-    inline bool is_inside(double x, double y) const
+    inline bool is_inside(const XY point) const
     {
-        return y >= m_y;
+        return point.y >= m_y;
     }
 };
 }
@@ -606,46 +612,30 @@ inline void clip_to_rect_one_step(const Polygon &polygon, Polygon &result, const
         return;
     }
 
-    auto [sx, sy] = polygon.back();
-    for (auto [px, py] : polygon) {
-        sinside = filter.is_inside(sx, sy);
-        pinside = filter.is_inside(px, py);
+    auto s = polygon.back();
+    for (auto p : polygon) {
+        sinside = filter.is_inside(s);
+        pinside = filter.is_inside(p);
 
         if (sinside ^ pinside) {
-            double bx, by;
-            filter.bisect(sx, sy, px, py, &bx, &by);
-            result.emplace_back(bx, by);
+            result.emplace_back(filter.bisect(s, p));
         }
 
         if (pinside) {
-            result.emplace_back(px, py);
+            result.emplace_back(p);
         }
 
-        sx = px;
-        sy = py;
+        s = p;
     }
 }
 
 template <class PathIterator>
-void
-clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vector<Polygon> &results)
+auto
+clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside)
 {
-    double xmin, ymin, xmax, ymax;
-    if (rect.x1 < rect.x2) {
-        xmin = rect.x1;
-        xmax = rect.x2;
-    } else {
-        xmin = rect.x2;
-        xmax = rect.x1;
-    }
-
-    if (rect.y1 < rect.y2) {
-        ymin = rect.y1;
-        ymax = rect.y2;
-    } else {
-        ymin = rect.y2;
-        ymax = rect.y1;
-    }
+    rect.normalize();
+    auto xmin = rect.x1, xmax = rect.x2;
+    auto ymin = rect.y1, ymax = rect.y2;
 
     if (!inside) {
         std::swap(xmin, xmax);
@@ -656,26 +646,27 @@ clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vecto
     curve_t curve(path);
 
     Polygon polygon1, polygon2;
-    double x = 0, y = 0;
+    XY point;
     unsigned code = 0;
     curve.rewind(0);
+    std::vector<Polygon> results;
 
     do {
         // Grab the next subpath and store it in polygon1
         polygon1.clear();
         do {
             if (code == agg::path_cmd_move_to) {
-                polygon1.emplace_back(x, y);
+                polygon1.emplace_back(point);
             }
 
-            code = curve.vertex(&x, &y);
+            code = curve.vertex(&point.x, &point.y);
 
             if (code == agg::path_cmd_stop) {
                 break;
             }
 
             if (code != agg::path_cmd_move_to) {
-                polygon1.emplace_back(x, y);
+                polygon1.emplace_back(point);
             }
         } while ((code & agg::path_cmd_end_poly) != agg::path_cmd_end_poly);
 
@@ -694,6 +685,8 @@ clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vecto
     } while (code != agg::path_cmd_stop);
 
     _finalize_polygon(results, true);
+
+    return results;
 }
 
 template <class VerticesArray, class ResultArray>
diff --git a/src/_path_wrapper.cpp b/src/_path_wrapper.cpp
index fd80b02b85ae..802189c428d3 100644
--- a/src/_path_wrapper.cpp
+++ b/src/_path_wrapper.cpp
@@ -109,9 +109,7 @@ Py_path_in_path(mpl::PathIterator a, agg::trans_affine atrans,
 static py::list
 Py_clip_path_to_rect(mpl::PathIterator path, agg::rect_d rect, bool inside)
 {
-    std::vector<Polygon> result;
-
-    clip_path_to_rect(path, rect, inside, result);
+    auto result = clip_path_to_rect(path, rect, inside);
 
     return convert_polygon_vector(result);
 }