Rename has_curves to has_codes

Because that is really what it checks and is for.

Author: QuLogic

src/_backend_agg.cpp

@@ -152,10 +152,10 @@ bool RendererAgg::render_clippath(py::PathIterator &clippath,
 
         rendererBaseAlphaMask.clear(agg::gray8(0, 0));
         transformed_path_t transformed_clippath(clippath, trans);
-        nan_removed_t nan_removed_clippath(transformed_clippath, true, clippath.has_curves());
+        nan_removed_t nan_removed_clippath(transformed_clippath, true, clippath.has_codes());
         snapped_t snapped_clippath(nan_removed_clippath, snap_mode, clippath.total_vertices(), 0.0);
         simplify_t simplified_clippath(snapped_clippath,
-                                       clippath.should_simplify() && !clippath.has_curves(),
+                                       clippath.should_simplify() && !clippath.has_codes(),
                                        clippath.simplify_threshold());
         curve_t curved_clippath(simplified_clippath);
         theRasterizer.add_path(curved_clippath);

src/_backend_agg.h

@@ -277,7 +277,7 @@ class RendererAgg
                                        DashesVector &linestyles,
                                        AntialiasedArray &antialiaseds,
                                        bool check_snap,
-                                       bool has_curves);
+                                       bool has_codes);
 
     template <class PointArray, class ColorArray>
     void _draw_gouraud_triangle(PointArray &points,
@@ -478,7 +478,7 @@ RendererAgg::draw_path(GCAgg &gc, PathIterator &path, agg::trans_affine &trans,
     }
 
     transformed_path_t tpath(path, trans);
-    nan_removed_t nan_removed(tpath, true, path.has_curves());
+    nan_removed_t nan_removed(tpath, true, path.has_codes());
     clipped_t clipped(nan_removed, clip, width, height);
     snapped_t snapped(clipped, gc.snap_mode, path.total_vertices(), snapping_linewidth);
     simplify_t simplified(snapped, simplify, path.simplify_threshold());
@@ -512,7 +512,7 @@ inline void RendererAgg::draw_markers(GCAgg &gc,
     trans *= agg::trans_affine_translation(0.5, (double)height + 0.5);
 
     transformed_path_t marker_path_transformed(marker_path, marker_trans);
-    nan_removed_t marker_path_nan_removed(marker_path_transformed, true, marker_path.has_curves());
+    nan_removed_t marker_path_nan_removed(marker_path_transformed, true, marker_path.has_codes());
     snap_t marker_path_snapped(marker_path_nan_removed,
                                gc.snap_mode,
                                marker_path.total_vertices(),
@@ -910,7 +910,7 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
                                                        DashesVector &linestyles,
                                                        AntialiasedArray &antialiaseds,
                                                        bool check_snap,
-                                                       bool has_curves)
+                                                       bool has_codes)
 {
     typedef agg::conv_transform<typename PathGenerator::path_iterator> transformed_path_t;
     typedef PathNanRemover<transformed_path_t> nan_removed_t;
@@ -998,11 +998,11 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
             gc.isaa = antialiaseds(i % Naa);
 
             transformed_path_t tpath(path, trans);
-            nan_removed_t nan_removed(tpath, true, has_curves);
+            nan_removed_t nan_removed(tpath, true, has_codes);
             clipped_t clipped(nan_removed, do_clip, width, height);
             snapped_t snapped(
                 clipped, gc.snap_mode, path.total_vertices(), points_to_pixels(gc.linewidth));
-            if (has_curves) {
+            if (has_codes) {
                 snapped_curve_t curve(snapped);
                 _draw_path(curve, has_clippath, face, gc);
             } else {
@@ -1012,9 +1012,9 @@ inline void RendererAgg::_draw_path_collection_generic(GCAgg &gc,
             gc.isaa = antialiaseds(i % Naa);
 
             transformed_path_t tpath(path, trans);
-            nan_removed_t nan_removed(tpath, true, has_curves);
+            nan_removed_t nan_removed(tpath, true, has_codes);
             clipped_t clipped(nan_removed, do_clip, width, height);
-            if (has_curves) {
+            if (has_codes) {
                 curve_t curve(clipped);
                 _draw_path(curve, has_clippath, face, gc);
             } else {

src/_path.h

@@ -259,7 +259,7 @@ inline void points_in_path(PointArray &points,
     }
 
     transformed_path_t trans_path(path, trans);
-    no_nans_t no_nans_path(trans_path, true, path.has_curves());
+    no_nans_t no_nans_path(trans_path, true, path.has_codes());
     curve_t curved_path(no_nans_path);
     if (r != 0.0) {
         contour_t contoured_path(curved_path);
@@ -305,7 +305,7 @@ void points_on_path(PointArray &points,
     }
 
     transformed_path_t trans_path(path, trans);
-    no_nans_t nan_removed_path(trans_path, true, path.has_curves());
+    no_nans_t nan_removed_path(trans_path, true, path.has_codes());
     curve_t curved_path(nan_removed_path);
     stroke_t stroked_path(curved_path);
     stroked_path.width(r * 2.0);
@@ -378,7 +378,7 @@ void update_path_extents(PathIterator &path, agg::trans_affine &trans, extent_li
     unsigned code;
 
     transformed_path_t tpath(path, trans);
-    nan_removed_t nan_removed(tpath, true, path.has_curves());
+    nan_removed_t nan_removed(tpath, true, path.has_codes());
 
     nan_removed.rewind(0);
 
@@ -512,7 +512,7 @@ bool path_in_path(PathIterator1 &a,
     }
 
     transformed_path_t b_path_trans(b, btrans);
-    no_nans_t b_no_nans(b_path_trans, true, b.has_curves());
+    no_nans_t b_no_nans(b_path_trans, true, b.has_codes());
     curve_t b_curved(b_no_nans);
 
     double x, y;
@@ -884,8 +884,8 @@ bool path_intersects_path(PathIterator1 &p1, PathIterator2 &p2)
         return false;
     }
 
-    no_nans_t n1(p1, true, p1.has_curves());
-    no_nans_t n2(p2, true, p2.has_curves());
+    no_nans_t n1(p1, true, p1.has_codes());
+    no_nans_t n2(p2, true, p2.has_codes());
 
     curve_t c1(n1);
     curve_t c2(n2);
@@ -949,7 +949,7 @@ bool path_intersects_rectangle(PathIterator &path,
         return false;
     }
 
-    no_nans_t no_nans(path, true, path.has_curves());
+    no_nans_t no_nans(path, true, path.has_codes());
     curve_t curve(no_nans);
 
     double cx = (rect_x1 + rect_x2) * 0.5, cy = (rect_y1 + rect_y2) * 0.5;
@@ -998,7 +998,7 @@ void convert_path_to_polygons(PathIterator &path,
     bool simplify = path.should_simplify();
 
     transformed_path_t tpath(path, trans);
-    nan_removal_t nan_removed(tpath, true, path.has_curves());
+    nan_removal_t nan_removed(tpath, true, path.has_codes());
     clipped_t clipped(nan_removed, do_clip, width, height);
     simplify_t simplified(clipped, simplify, path.simplify_threshold());
     curve_t curve(simplified);
@@ -1063,7 +1063,7 @@ void cleanup_path(PathIterator &path,
     typedef Sketch<curve_t> sketch_t;
 
     transformed_path_t tpath(path, trans);
-    nan_removal_t nan_removed(tpath, remove_nans, path.has_curves());
+    nan_removal_t nan_removed(tpath, remove_nans, path.has_codes());
     clipped_t clipped(nan_removed, do_clip, rect);
     snapped_t snapped(clipped, snap_mode, path.total_vertices(), stroke_width);
     simplify_t simplified(snapped, do_simplify, path.simplify_threshold());
@@ -1222,7 +1222,7 @@ bool convert_to_string(PathIterator &path,
     bool do_clip = (clip_rect.x1 < clip_rect.x2 && clip_rect.y1 < clip_rect.y2);
 
     transformed_path_t tpath(path, trans);
-    nan_removal_t nan_removed(tpath, true, path.has_curves());
+    nan_removal_t nan_removed(tpath, true, path.has_codes());
     clipped_t clipped(nan_removed, do_clip, clip_rect);
     simplify_t simplified(clipped, simplify, path.simplify_threshold());
 

src/path_converters.h

@@ -162,16 +162,16 @@ class PathNanRemover : protected EmbeddedQueue<4>
 {
     VertexSource *m_source;
     bool m_remove_nans;
-    bool m_has_curves;
+    bool m_has_codes;
     bool valid_segment_exists;
 
   public:
-    /* has_curves should be true if the path contains bezier curve
-       segments, as this requires a slower algorithm to remove the
-       NaNs.  When in doubt, set to true.
+    /* has_codes should be true if the path contains bezier curve segments, or
+     * closed loops, as this requires a slower algorithm to remove the NaNs.
+     * When in doubt, set to true.
      */
-    PathNanRemover(VertexSource &source, bool remove_nans, bool has_curves)
-        : m_source(&source), m_remove_nans(remove_nans), m_has_curves(has_curves)
+    PathNanRemover(VertexSource &source, bool remove_nans, bool has_codes)
+        : m_source(&source), m_remove_nans(remove_nans), m_has_codes(has_codes)
     {
         // ignore all close/end_poly commands until after the first valid
         // (nan-free) command is encountered
@@ -192,8 +192,9 @@ class PathNanRemover : protected EmbeddedQueue<4>
             return m_source->vertex(x, y);
         }
 
-        if (m_has_curves) {
-            /* This is the slow method for when there might be curves. */
+        if (m_has_codes) {
+	    /* This is the slow method for when there might be curves or closed
+	     * loops. */
             if (queue_pop(&code, x, y)) {
                 return code;
             }
@@ -254,9 +255,9 @@ class PathNanRemover : protected EmbeddedQueue<4>
             } else {
                 return agg::path_cmd_stop;
             }
-        } else // !m_has_curves
+        } else // !m_has_codes
         {
-            /* This is the fast path for when we know we have no curves */
+            /* This is the fast path for when we know we have no codes. */
             code = m_source->vertex(x, y);
 
             if (code == agg::path_cmd_stop ||

src/py_adaptors.h

@@ -175,7 +175,7 @@ class PathIterator
         return m_simplify_threshold;
     }
 
-    inline bool has_curves() const
+    inline bool has_codes() const
     {
         return m_codes != NULL;
     }