path: Simplify parts of clip_path_to_rect

QuLogic · QuLogic · commit b64f3d74f413 · 2025-09-11T05:27:21.000-04:00
Use `XY` type to shorten internals, and `agg::rect_d::normalize` to
shorten initialization.
diff --git 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
@@ -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);
 }

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,8 @@ struct XY`
`26`	`26`	`double x;`
`27`	`27`	`double y;`
`28`	`28`
	`29`	`+ XY() : x(0), y(0) {}`
	`30`	`+`
`29`	`31`	`XY(double x_, double y_) : x(x_), y(y_)`
`30`	`32`	`{`
`31`	`33`	`}`
`@@ -521,12 +523,14 @@ struct bisectx`
`521`	`523`	`{`
`522`	`524`	`}`
`523`	`525`
`524`		`- inline void bisect(double sx, double sy, double px, double py, double bx, double by) const`
	`526`	`+ inline XY bisect(const XY s, const XY p) const`
`525`	`527`	`{`
`526`		`- *bx = m_x;`
`527`		`- double dx = px - sx;`
`528`		`- double dy = py - sy;`
`529`		`- by = sy + dy ((m_x - sx) / dx);`
	`528`	`+ double dx = p.x - s.x;`
	`529`	`+ double dy = p.y - s.y;`
	`530`	`+ return {`
	`531`	`+ m_x,`
	`532`	`+ s.y + dy * ((m_x - s.x) / dx),`
	`533`	`+ };`
`530`	`534`	`}`
`531`	`535`	`};`
`532`	`536`
`@@ -536,9 +540,9 @@ struct xlt : public bisectx`
`536`	`540`	`{`
`537`	`541`	`}`
`538`	`542`
`539`		`- inline bool is_inside(double x, double y) const`
	`543`	`+ inline bool is_inside(const XY point) const`
`540`	`544`	`{`
`541`		`- return x <= m_x;`
	`545`	`+ return point.x <= m_x;`
`542`	`546`	`}`
`543`	`547`	`};`
`544`	`548`
`@@ -548,9 +552,9 @@ struct xgt : public bisectx`
`548`	`552`	`{`
`549`	`553`	`}`
`550`	`554`
`551`		`- inline bool is_inside(double x, double y) const`
	`555`	`+ inline bool is_inside(const XY point) const`
`552`	`556`	`{`
`553`		`- return x >= m_x;`
	`557`	`+ return point.x >= m_x;`
`554`	`558`	`}`
`555`	`559`	`};`
`556`	`560`
`@@ -562,12 +566,14 @@ struct bisecty`
`562`	`566`	`{`
`563`	`567`	`}`
`564`	`568`
`565`		`- inline void bisect(double sx, double sy, double px, double py, double bx, double by) const`
	`569`	`+ inline XY bisect(const XY s, const XY p) const`
`566`	`570`	`{`
`567`		`- *by = m_y;`
`568`		`- double dx = px - sx;`
`569`		`- double dy = py - sy;`
`570`		`- bx = sx + dx ((m_y - sy) / dy);`
	`571`	`+ double dx = p.x - s.x;`
	`572`	`+ double dy = p.y - s.y;`
	`573`	`+ return {`
	`574`	`+ s.x + dx * ((m_y - s.y) / dy),`
	`575`	`+ m_y,`
	`576`	`+ };`
`571`	`577`	`}`
`572`	`578`	`};`
`573`	`579`
`@@ -577,9 +583,9 @@ struct ylt : public bisecty`
`577`	`583`	`{`
`578`	`584`	`}`
`579`	`585`
`580`		`- inline bool is_inside(double x, double y) const`
	`586`	`+ inline bool is_inside(const XY point) const`
`581`	`587`	`{`
`582`		`- return y <= m_y;`
	`588`	`+ return point.y <= m_y;`
`583`	`589`	`}`
`584`	`590`	`};`
`585`	`591`
`@@ -589,9 +595,9 @@ struct ygt : public bisecty`
`589`	`595`	`{`
`590`	`596`	`}`
`591`	`597`
`592`		`- inline bool is_inside(double x, double y) const`
	`598`	`+ inline bool is_inside(const XY point) const`
`593`	`599`	`{`
`594`		`- return y >= m_y;`
	`600`	`+ return point.y >= m_y;`
`595`	`601`	`}`
`596`	`602`	`};`
`597`	`603`	`}`
`@@ -606,46 +612,30 @@ inline void clip_to_rect_one_step(const Polygon &polygon, Polygon &result, const`
`606`	`612`	`return;`
`607`	`613`	`}`
`608`	`614`
`609`		`- auto [sx, sy] = polygon.back();`
`610`		`- for (auto [px, py] : polygon) {`
`611`		`- sinside = filter.is_inside(sx, sy);`
`612`		`- pinside = filter.is_inside(px, py);`
	`615`	`+ auto s = polygon.back();`
	`616`	`+ for (auto p : polygon) {`
	`617`	`+ sinside = filter.is_inside(s);`
	`618`	`+ pinside = filter.is_inside(p);`
`613`	`619`
`614`	`620`	`if (sinside ^ pinside) {`
`615`		`- double bx, by;`
`616`		`- filter.bisect(sx, sy, px, py, &bx, &by);`
`617`		`- result.emplace_back(bx, by);`
	`621`	`+ result.emplace_back(filter.bisect(s, p));`
`618`	`622`	`}`
`619`	`623`
`620`	`624`	`if (pinside) {`
`621`		`- result.emplace_back(px, py);`
	`625`	`+ result.emplace_back(p);`
`622`	`626`	`}`
`623`	`627`
`624`		`- sx = px;`
`625`		`- sy = py;`
	`628`	`+ s = p;`
`626`	`629`	`}`
`627`	`630`	`}`
`628`	`631`
`629`	`632`	`template <class PathIterator>`
`630`		`-void`
`631`		`-clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vector<Polygon> &results)`
	`633`	`+auto`
	`634`	`+clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside)`
`632`	`635`	`{`
`633`		`- double xmin, ymin, xmax, ymax;`
`634`		`- if (rect.x1 < rect.x2) {`
`635`		`- xmin = rect.x1;`
`636`		`- xmax = rect.x2;`
`637`		`- } else {`
`638`		`- xmin = rect.x2;`
`639`		`- xmax = rect.x1;`
`640`		`- }`
`641`		`-`
`642`		`- if (rect.y1 < rect.y2) {`
`643`		`- ymin = rect.y1;`
`644`		`- ymax = rect.y2;`
`645`		`- } else {`
`646`		`- ymin = rect.y2;`
`647`		`- ymax = rect.y1;`
`648`		`- }`
	`636`	`+ rect.normalize();`
	`637`	`+ auto xmin = rect.x1, xmax = rect.x2;`
	`638`	`+ auto ymin = rect.y1, ymax = rect.y2;`
`649`	`639`
`650`	`640`	`if (!inside) {`
`651`	`641`	`std::swap(xmin, xmax);`
`@@ -656,26 +646,27 @@ clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vecto`
`656`	`646`	`curve_t curve(path);`
`657`	`647`
`658`	`648`	`Polygon polygon1, polygon2;`
`659`		`- double x = 0, y = 0;`
	`649`	`+ XY point;`
`660`	`650`	`unsigned code = 0;`
`661`	`651`	`curve.rewind(0);`
	`652`	`+ std::vector<Polygon> results;`
`662`	`653`
`663`	`654`	`do {`
`664`	`655`	`// Grab the next subpath and store it in polygon1`
`665`	`656`	`polygon1.clear();`
`666`	`657`	`do {`
`667`	`658`	`if (code == agg::path_cmd_move_to) {`
`668`		`- polygon1.emplace_back(x, y);`
	`659`	`+ polygon1.emplace_back(point);`
`669`	`660`	`}`
`670`	`661`
`671`		`- code = curve.vertex(&x, &y);`
	`662`	`+ code = curve.vertex(&point.x, &point.y);`
`672`	`663`
`673`	`664`	`if (code == agg::path_cmd_stop) {`
`674`	`665`	`break;`
`675`	`666`	`}`
`676`	`667`
`677`	`668`	`if (code != agg::path_cmd_move_to) {`
`678`		`- polygon1.emplace_back(x, y);`
	`669`	`+ polygon1.emplace_back(point);`
`679`	`670`	`}`
`680`	`671`	`} while ((code & agg::path_cmd_end_poly) != agg::path_cmd_end_poly);`
`681`	`672`
`@@ -694,6 +685,8 @@ clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vecto`
`694`	`685`	`} while (code != agg::path_cmd_stop);`
`695`	`686`
`696`	`687`	`_finalize_polygon(results, true);`
	`688`	`+`
	`689`	`+ return results;`
`697`	`690`	`}`
`698`	`691`
`699`	`692`	`template <class VerticesArray, class ResultArray>`
Original file line number	Diff line number	Diff line change
`@@ -109,9 +109,7 @@ Py_path_in_path(mpl::PathIterator a, agg::trans_affine atrans,`
`109`	`109`	`static py::list`
`110`	`110`	`Py_clip_path_to_rect(mpl::PathIterator path, agg::rect_d rect, bool inside)`
`111`	`111`	`{`
`112`		`- std::vector<Polygon> result;`
`113`		`-`
`114`		`- clip_path_to_rect(path, rect, inside, result);`
	`112`	`+ auto result = clip_path_to_rect(path, rect, inside);`
`115`	`113`
`116`	`114`	`return convert_polygon_vector(result);`
`117`	`115`	`}`