Implement a better way to handle overflow in the Agg backend.

Author: mdboom

agg24/include/agg_rasterizer_cells_aa.h

@@ -29,8 +29,7 @@
 #ifndef AGG_RASTERIZER_CELLS_AA_INCLUDED
 #define AGG_RASTERIZER_CELLS_AA_INCLUDED
 
-#include "CXX/Exception.hxx"
-#include <exception>
+#include <stdexcept>
 #include <string.h>
 #include <math.h>
 #include "agg_math.h"
@@ -183,9 +182,9 @@ namespace agg
         {
             if((m_num_cells & cell_block_mask) == 0)
             {
-                if(m_num_blocks >= cell_block_limit) {
-                    throw Py::OverflowError(
-                            "Agg rendering complexity exceeded. Consider downsampling or decimating your data.");
+                if (m_num_blocks >= cell_block_limit)
+                {
+                    throw std::overflow_error("Allocated too many blocks");
                 }
                 allocate_block();
             }

src/_backend_agg.cpp

@@ -619,7 +619,11 @@ RendererAgg::render_clippath(const Py::Object& clippath,
         rendererBaseAlphaMask.clear(agg::gray8(0, 0));
         transformed_path_t transformed_clippath(clippath_iter, trans);
         agg::conv_curve<transformed_path_t> curved_clippath(transformed_clippath);
-        theRasterizer.add_path(curved_clippath);
+        try {
+            theRasterizer.add_path(curved_clippath);
+        } catch (std::overflow_error &e) {
+            throw Py::OverflowError(e.what());
+        }
         rendererAlphaMask.color(agg::gray8(255, 255));
         agg::render_scanlines(theRasterizer, scanlineAlphaMask, rendererAlphaMask);
         lastclippath = clippath;
@@ -698,7 +702,11 @@ RendererAgg::draw_markers(const Py::Tuple& args)
         unsigned fillSize = 0;
         if (face.first)
         {
-            theRasterizer.add_path(marker_path_curve);
+            try {
+                theRasterizer.add_path(marker_path_curve);
+            } catch (std::overflow_error &e) {
+                throw Py::OverflowError(e.what());
+            }
             agg::render_scanlines(theRasterizer, slineP8, scanlines);
             fillSize = scanlines.byte_size();
             if (fillSize >= MARKER_CACHE_SIZE)
@@ -713,7 +721,11 @@ RendererAgg::draw_markers(const Py::Tuple& args)
         stroke.line_cap(gc.cap);
         stroke.line_join(gc.join);
         theRasterizer.reset();
-        theRasterizer.add_path(stroke);
+        try {
+            theRasterizer.add_path(stroke);
+        } catch (std::overflow_error &e) {
+            throw Py::OverflowError(e.what());
+        }
         agg::render_scanlines(theRasterizer, slineP8, scanlines);
         unsigned strokeSize = scanlines.byte_size();
         if (strokeSize >= MARKER_CACHE_SIZE)
@@ -980,7 +992,11 @@ RendererAgg::draw_text_image(const Py::Tuple& args)
     span_gen_type output_span_generator(&image_span_generator, gc.color);
     renderer_type ri(rendererBase, sa, output_span_generator);
 
-    theRasterizer.add_path(rect2);
+    try {
+        theRasterizer.add_path(rect2);
+    } catch (std::overflow_error &e) {
+        throw Py::OverflowError(e.what());
+    }
     agg::render_scanlines(theRasterizer, slineP8, ri);
 
     return Py::Object();
@@ -1117,7 +1133,11 @@ RendererAgg::draw_image(const Py::Tuple& args)
             amask_ren_type r(pfa);
             renderer_type_alpha ri(r, sa, spans);
 
-            theRasterizer.add_path(rect2);
+            try {
+                theRasterizer.add_path(rect2);
+            } catch (std::overflow_error &e) {
+                throw Py::OverflowError(e.what());
+            }
             agg::render_scanlines(theRasterizer, slineP8, ri);
         }
         else
@@ -1131,7 +1151,11 @@ RendererAgg::draw_image(const Py::Tuple& args)
             ren_type r(pixFmt);
             renderer_type ri(r, sa, spans);
 
-            theRasterizer.add_path(rect2);
+            try {
+                theRasterizer.add_path(rect2);
+            } catch (std::overflow_error &e) {
+                throw Py::OverflowError(e.what());
+            }
             agg::render_scanlines(theRasterizer, slineP8, ri);
         }
 
@@ -1166,7 +1190,11 @@ void RendererAgg::_draw_path(path_t& path, bool has_clippath,
     // Render face
     if (face.first)
     {
-        theRasterizer.add_path(path);
+        try {
+            theRasterizer.add_path(path);
+        } catch (std::overflow_error &e) {
+            throw Py::OverflowError(e.what());
+        }
 
         if (gc.isaa)
         {
@@ -1233,9 +1261,17 @@ void RendererAgg::_draw_path(path_t& path, bool has_clippath,
         rb.clear(agg::rgba(0.0, 0.0, 0.0, 0.0));
         rs.color(gc.color);
 
-        theRasterizer.add_path(hatch_path_curve);
+        try {
+            theRasterizer.add_path(hatch_path_curve);
+        } catch (std::overflow_error &e) {
+            throw Py::OverflowError(e.what());
+        }
         agg::render_scanlines(theRasterizer, slineP8, rs);
-        theRasterizer.add_path(hatch_path_stroke);
+        try {
+            theRasterizer.add_path(hatch_path_stroke);
+        } catch (std::overflow_error &e) {
+            throw Py::OverflowError(e.what());
+        }
         agg::render_scanlines(theRasterizer, slineP8, rs);
 
         // Put clipping back on, if originally set on entry to this
@@ -1252,7 +1288,11 @@ void RendererAgg::_draw_path(path_t& path, bool has_clippath,
         agg::span_allocator<agg::rgba8> sa;
         img_source_type img_src(hatch_img_pixf);
         span_gen_type sg(img_src, 0, 0);
-        theRasterizer.add_path(path);
+        try {
+            theRasterizer.add_path(path);
+        } catch (std::overflow_error &e) {
+            throw Py::OverflowError(e.what());
+        }
         agg::render_scanlines_aa(theRasterizer, slineP8, rendererBase, sa, sg);
     }
 
@@ -1270,7 +1310,11 @@ void RendererAgg::_draw_path(path_t& path, bool has_clippath,
             stroke.width(linewidth);
             stroke.line_cap(gc.cap);
             stroke.line_join(gc.join);
-            theRasterizer.add_path(stroke);
+            try {
+                theRasterizer.add_path(stroke);
+            } catch (std::overflow_error &e) {
+                throw Py::OverflowError(e.what());
+            }
         }
         else
         {
@@ -1291,7 +1335,11 @@ void RendererAgg::_draw_path(path_t& path, bool has_clippath,
             stroke.line_cap(gc.cap);
             stroke.line_join(gc.join);
             stroke.width(linewidth);
-            theRasterizer.add_path(stroke);
+            try {
+                theRasterizer.add_path(stroke);
+            } catch (std::overflow_error &e) {
+                throw Py::OverflowError(e.what());
+            }
         }
 
         if (gc.isaa)
@@ -1888,7 +1936,12 @@ RendererAgg::_draw_gouraud_triangle(const double* points,
         tpoints[4], tpoints[5],
         0.5);
 
-    theRasterizer.add_path(span_gen);
+    try {
+        theRasterizer.add_path(span_gen);
+    } catch (std::overflow_error &e) {
+        throw Py::OverflowError(e.what()
+                                );
+    }
 
     if (has_clippath)
     {