Merge remote-tracking branch 'matplotlib/v1.5.x' into v2.x

tacaswell · tacaswell · commit 4fc85b05db37 · 2016-02-24T23:20:36.000-05:00
diff --git a/doc/users/artists.rst b/doc/users/artists.rst
@@ -156,9 +156,9 @@ MATLAB, and is a 2D "patch" of color on the figure, e.g., rectangles,
 circles and polygons).  Every matplotlib ``Artist`` has the following
 properties
 
-==========   ======================================================================
+==========   ================================================================================
 Property     Description
-==========   ======================================================================
+==========   ================================================================================
 alpha 	     The transparency - a scalar from 0-1
 animated     A boolean that is used to facilitate animated drawing
 axes         The axes that the Artist lives in, possibly None
@@ -172,7 +172,8 @@ picker       A python object that controls object picking
 transform    The transformation
 visible      A boolean whether the artist should be drawn
 zorder       A number which determines the drawing order
-==========   ======================================================================
+rasterized   Boolean; Turns vectors into rastergraphics: (for compression & eps transparency)
+==========   ================================================================================
 
 Each of the properties is accessed with an old-fashioned setter or
 getter (yes we know this irritates Pythonistas and we plan to support
diff --git a/doc/users/navigation_toolbar.rst b/doc/users/navigation_toolbar.rst
@@ -110,6 +110,8 @@ depends on your UI, but we have examples for every supported UI in the
 example code for GTK::
 
 
+    import gtk
+
     from matplotlib.figure import Figure
     from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
     from matplotlib.backends.backend_gtkagg import NavigationToolbar2GTKAgg as NavigationToolbar
diff --git a/doc/users/pgf.rst b/doc/users/pgf.rst
@@ -160,7 +160,17 @@ Troubleshooting
   in yout LaTeX document, the alignment of text elements in imported figures
   may be off. Check the header of your ``.pgf`` file if you are unsure about
   the fonts matplotlib used for the layout.
-
+  
+* Vector images and hence ``.pgf`` files can become bloated if there are a lot 
+  of objects in the graph. This can be the case for image processing or very
+  big scatter graphs.  In an extreme case this can cause TeX to run out of 
+  memory: "TeX capacity exceeded, sorry"  You can configure latex to increase 
+  the amount of memory available to generate the ``.pdf`` image as discussed on  
+  `tex.stackexchange.com <http://tex.stackexchange.com/questions/7953>`_.
+  Another way would be to "rasterize" parts of the graph causing problems 
+  using either the ``rasterized=True`` keyword, or ``.set_rasterized(True)`` as per 
+  `this example <http://matplotlib.org/examples/misc/rasterization_demo.html>`_.
+  
 * If you still need help, please see :ref:`reporting-problems`
 
 .. _LaTeX: http://www.tug.org
diff --git a/lib/matplotlib/tests/test_simplification.py b/lib/matplotlib/tests/test_simplification.py
@@ -212,6 +212,22 @@ def test_clipping_with_nans():
     ax.set_ylim(-0.25, 0.25)
 
 
+def test_clipping_full():
+    p = path.Path([[1e30, 1e30]] * 5)
+    simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))
+    assert simplified == []
+
+    p = path.Path([[50, 40], [75, 65]], [1, 2])
+    simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))
+    assert ([(list(x), y) for x, y in simplified] ==
+            [([50, 40], 1), ([75, 65], 2)])
+
+    p = path.Path([[50, 40]], [1])
+    simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))
+    assert ([(list(x), y) for x, y in simplified] ==
+            [([50, 40], 1)])
+
+
 if __name__=='__main__':
     import nose
     nose.runmodule(argv=['-s','--with-doctest'], exit=False)
diff --git a/src/path_converters.h b/src/path_converters.h
@@ -278,33 +278,25 @@ class PathNanRemover : protected EmbeddedQueue<4>
  clipped, but are always included in their entirety.
  */
 template <class VertexSource>
-class PathClipper
+class PathClipper : public EmbeddedQueue<3>
 {
     VertexSource *m_source;
     bool m_do_clipping;
     agg::rect_base<double> m_cliprect;
     double m_lastX;
     double m_lastY;
     bool m_moveto;
-    double m_nextX;
-    double m_nextY;
-    bool m_has_next;
-    bool m_end_poly;
     double m_initX;
     double m_initY;
     bool m_has_init;
-    bool m_broke_path;
 
   public:
     PathClipper(VertexSource &source, bool do_clipping, double width, double height)
         : m_source(&source),
           m_do_clipping(do_clipping),
           m_cliprect(-1.0, -1.0, width + 1.0, height + 1.0),
           m_moveto(true),
-          m_has_next(false),
-          m_end_poly(false),
-          m_has_init(false),
-          m_broke_path(false)
+          m_has_init(false)
     {
         // empty
     }
@@ -314,10 +306,7 @@ class PathClipper
           m_do_clipping(do_clipping),
           m_cliprect(rect),
           m_moveto(true),
-          m_has_next(false),
-          m_end_poly(false),
-          m_has_init(false),
-          m_broke_path(false)
+          m_has_init(false)
     {
         m_cliprect.x1 -= 1.0;
         m_cliprect.y1 -= 1.0;
@@ -327,86 +316,100 @@ class PathClipper
 
     inline void rewind(unsigned path_id)
     {
-        m_has_next = false;
+        m_has_init = false;
         m_moveto = true;
         m_source->rewind(path_id);
     }
 
+    int draw_clipped_line(double x0, double y0, double x1, double y1)
+    {
+        unsigned moved = agg::clip_line_segment(&x0, &y0, &x1, &y1, m_cliprect);
+        // moved >= 4 - Fully clipped
+        // moved & 1 != 0 - First point has been moved
+        // moved & 2 != 0 - Second point has been moved
+        if (moved < 4) {
+            if (moved & 1 || m_moveto) {
+                queue_push(agg::path_cmd_move_to, x0, y0);
+            }
+            queue_push(agg::path_cmd_line_to, x1, y1);
+
+            m_moveto = false;
+            return 1;
+        }
+
+        return 0;
+    }
+
     unsigned vertex(double *x, double *y)
     {
         unsigned code;
 
         if (m_do_clipping) {
             /* This is the slow path where we actually do clipping */
 
-            if (m_end_poly) {
-                m_end_poly = false;
-                return (agg::path_cmd_end_poly | agg::path_flags_close);
-            }
-
-            if (m_has_next) {
-                m_has_next = false;
-                *x = m_nextX;
-                *y = m_nextY;
-                return agg::path_cmd_line_to;
+            if (queue_pop(&code, x, y)) {
+                return code;
             }
 
             while ((code = m_source->vertex(x, y)) != agg::path_cmd_stop) {
-                if (code == (agg::path_cmd_end_poly | agg::path_flags_close)) {
+                switch (code) {
+                case (agg::path_cmd_end_poly | agg::path_flags_close):
                     if (m_has_init) {
-                        *x = m_initX;
-                        *y = m_initY;
-                        code = agg::path_cmd_line_to;
-                        m_end_poly = true;
-                    } else {
-                        continue;
+                        draw_clipped_line(m_lastX, m_lastY, m_initX, m_initY);
                     }
-                }
-
-                if (code == agg::path_cmd_move_to) {
-                    m_initX = *x;
-                    m_initY = *y;
+                    queue_push(
+                        agg::path_cmd_end_poly | agg::path_flags_close,
+                        m_lastX, m_lastY);
+                    goto exit_loop;
+
+                case agg::path_cmd_move_to:
+                    m_initX = m_lastX = *x;
+                    m_initY = m_lastY = *y;
                     m_has_init = true;
                     m_moveto = true;
-                }
-                if (m_moveto) {
-                    m_moveto = false;
-                    code = agg::path_cmd_move_to;
                     break;
-                } else if (code == agg::path_cmd_line_to) {
-                    double x0, y0, x1, y1;
-                    x0 = m_lastX;
-                    y0 = m_lastY;
-                    x1 = *x;
-                    y1 = *y;
+
+                case agg::path_cmd_line_to:
+                    if (draw_clipped_line(m_lastX, m_lastY, *x, *y)) {
+                        m_lastX = *x;
+                        m_lastY = *y;
+                        goto exit_loop;
+                    }
                     m_lastX = *x;
                     m_lastY = *y;
-                    unsigned moved = agg::clip_line_segment(&x0, &y0, &x1, &y1, m_cliprect);
-                    // moved >= 4 - Fully clipped
-                    // moved & 1 != 0 - First point has been moved
-                    // moved & 2 != 0 - Second point has been moved
-                    if (moved < 4) {
-                        if (moved & 1) {
-                            *x = x0;
-                            *y = y0;
-                            m_nextX = x1;
-                            m_nextY = y1;
-                            m_has_next = true;
-                            m_broke_path = true;
-                            return agg::path_cmd_move_to;
-                        }
-                        *x = x1;
-                        *y = y1;
-                        return code;
-                    }
-                } else {
                     break;
+
+                default:
+                    if (m_moveto) {
+                        queue_push(agg::path_cmd_move_to, m_lastX, m_lastY);
+                        m_moveto = false;
+                    }
+
+                    queue_push(code, *x, *y);
+                    m_lastX = *x;
+                    m_lastY = *y;
+                    goto exit_loop;
                 }
             }
 
-            m_lastX = *x;
-            m_lastY = *y;
-            return code;
+        exit_loop:
+
+            if (queue_pop(&code, x, y)) {
+                return code;
+            }
+
+            if (m_moveto &&
+                m_lastX >= m_cliprect.x1 &&
+                m_lastX <= m_cliprect.x2 &&
+                m_lastY >= m_cliprect.y1 &&
+                m_lastY <= m_cliprect.y2) {
+                *x = m_lastX;
+                *y = m_lastY;
+                m_moveto = false;
+                return agg::path_cmd_move_to;
+            }
+
+            return agg::path_cmd_stop;
         } else {
             // If not doing any clipping, just pass along the vertices
             // verbatim
