Does simplify paths when NaN/inf is present.

mdboom · mdboom · commit 9e1f7b5f2551 · 2008-08-11T12:48:50.000Z
svn path=/trunk/matplotlib/; revision=6018
diff --git a/CHANGELOG b/CHANGELOG
@@ -1,3 +1,9 @@
+2008-08-11 Fix more bugs in NaN/inf handling.  In particular, path simplification
+           (which does not handle NaNs or infs) will be turned off automatically
+           when infs or NaNs are present.  Also masked arrays are now converted
+           to arrays with NaNs for consistent handling of masks and NaNs
+            - MGD and EF
+
 =================================================================
 2008-08-03 Released 0.98.3 at svn r5947
 
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -56,6 +56,11 @@ class Path(object):
     :class:`Path` objects, as an optimization, do not store a *codes*
     at all, but have a default one provided for them by
     :meth:`iter_segments`.
+
+    Note also that the vertices and codes arrays should be treated as
+    immutable -- there are a number of optimizations and assumptions
+    made up front in the constructor that will not change when the
+    data changes.
     """
 
     # Path codes
@@ -84,46 +89,29 @@ def __init__(self, vertices, codes=None):
         dimension.
 
         If *codes* is None, *vertices* will be treated as a series of
-        line segments.  If *vertices* contains masked values, the
-        resulting path will be compressed, with ``MOVETO`` codes
-        inserted in the correct places to jump over the masked
-        regions.
+        line segments.
+
+        If *vertices* contains masked values, they will be converted
+        to NaNs which are then handled correctly by the Agg
+        PathIterator and other consumers of path data, such as
+        :meth:`iter_segments`.
         """
         if ma.isMaskedArray(vertices):
-            is_mask = True
-            mask = ma.getmask(vertices)
+            vertices = vertices.astype(np.float_).filled(np.nan)
         else:
-            is_mask = False
             vertices = np.asarray(vertices, np.float_)
-            mask = ma.nomask
 
         if codes is not None:
             codes = np.asarray(codes, self.code_type)
             assert codes.ndim == 1
             assert len(codes) == len(vertices)
 
-        # The path being passed in may have masked values.  However,
-        # the backends (and any affine transformations in matplotlib
-        # itself), are not expected to deal with masked arrays, so we
-        # must remove them from the array (using compressed), and add
-        # MOVETO commands to the codes array accordingly.
-        if is_mask:
-            if mask is not ma.nomask:
-                mask1d = np.logical_or.reduce(mask, axis=1)
-                gmask1d = np.invert(mask1d)
-                if codes is None:
-                    codes = np.empty((len(vertices)), self.code_type)
-                    codes.fill(self.LINETO)
-                    codes[0] = self.MOVETO
-                vertices = vertices[gmask1d].filled() # ndarray
-                codes[np.roll(mask1d, 1)] = self.MOVETO
-                codes = codes[gmask1d] # np.compress is much slower
-            else:
-                vertices = np.asarray(vertices, np.float_)
-
         assert vertices.ndim == 2
         assert vertices.shape[1] == 2
 
+        self.should_simplify = (codes is None and
+                                np.all(np.isfinite(vertices)) and
+                                len(vertices) >= 128)
         self.codes = codes
         self.vertices = vertices
 
diff --git a/src/_backend_agg.cpp b/src/_backend_agg.cpp
@@ -387,7 +387,7 @@ bool should_snap(Path& path, const agg::trans_affine& trans) {
   double x0, y0, x1, y1;
   unsigned code;
 
-  if (path.total_vertices() > 15)
+  if (!path.should_simplify() || path.total_vertices() > 15)
     return false;
 
   code = path.vertex(&x0, &y0);
@@ -420,11 +420,6 @@ bool should_snap(Path& path, const agg::trans_affine& trans) {
   return true;
 }
 
-template<class Path>
-bool should_simplify(Path& path) {
-  return !path.has_curves() && path.total_vertices() >= 128;
-}
-
 Py::Object
 RendererAgg::copy_from_bbox(const Py::Tuple& args) {
   //copy region in bbox to buffer and return swig/agg buffer object
@@ -938,7 +933,7 @@ RendererAgg::draw_path(const Py::Tuple& args) {
   trans *= agg::trans_affine_scaling(1.0, -1.0);
   trans *= agg::trans_affine_translation(0.0, (double)height);
   bool snap = should_snap(path, trans);
-  bool simplify = should_simplify(path) && !face.first;
+  bool simplify = path.should_simplify() && !face.first;
 
   transformed_path_t tpath(path, trans);
   simplify_t simplified(tpath, snap, simplify, width, height);
@@ -1236,6 +1231,10 @@ class QuadMeshGenerator {
     inline unsigned total_vertices() {
       return 5;
     }
+
+    inline bool should_simplify() {
+      return false;
+    }
   };
 
 public:
diff --git a/src/_path.cpp b/src/_path.cpp
@@ -1120,7 +1120,7 @@ Py::Object _path_module::convert_path_to_polygons(const Py::Tuple& args)
     double width = Py::Float(args[2]);
     double height = Py::Float(args[3]);
 
-    bool simplify = !path.has_curves() && width != 0.0 && height != 0.0;
+    bool simplify = path.should_simplify() && width != 0.0 && height != 0.0;
 
     transformed_path_t tpath(path, trans);
     simplify_t simplified(tpath, false, simplify, width, height);
diff --git a/src/agg_py_path_iterator.h b/src/agg_py_path_iterator.h
@@ -15,13 +15,15 @@ class PathIterator
     PyArrayObject* m_codes;
     size_t m_iterator;
     size_t m_total_vertices;
+    bool m_should_simplify;
 
 public:
     PathIterator(const Py::Object& path_obj) :
             m_vertices(NULL), m_codes(NULL), m_iterator(0)
     {
         Py::Object vertices_obj = path_obj.getAttr("vertices");
         Py::Object codes_obj = path_obj.getAttr("codes");
+        Py::Object should_simplify_obj = path_obj.getAttr("should_simplify");
 
         m_vertices = (PyArrayObject*)PyArray_FromObject
                      (vertices_obj.ptr(), PyArray_DOUBLE, 2, 2);
@@ -38,6 +40,7 @@ class PathIterator
                 throw Py::ValueError("Invalid codes array.");
         }
 
+        m_should_simplify = bool(Py::Int(should_simplify_obj));
         m_total_vertices = m_vertices->dimensions[0];
     }
 
@@ -100,9 +103,9 @@ class PathIterator
         return m_total_vertices;
     }
 
-    inline bool has_curves()
+    inline bool should_simplify()
     {
-        return m_codes;
+        return m_should_simplify;
     }
 };
 

Original file line number	Diff line number	Diff line change
`@@ -15,13 +15,15 @@ class PathIterator`
`15`	`15`	`PyArrayObject* m_codes;`
`16`	`16`	`size_t m_iterator;`
`17`	`17`	`size_t m_total_vertices;`
	`18`	`+ bool m_should_simplify;`
`18`	`19`
`19`	`20`	`public:`
`20`	`21`	`PathIterator(const Py::Object& path_obj) :`
`21`	`22`	`m_vertices(NULL), m_codes(NULL), m_iterator(0)`
`22`	`23`	`{`
`23`	`24`	`Py::Object vertices_obj = path_obj.getAttr("vertices");`
`24`	`25`	`Py::Object codes_obj = path_obj.getAttr("codes");`
	`26`	`+ Py::Object should_simplify_obj = path_obj.getAttr("should_simplify");`
`25`	`27`
`26`	`28`	`m_vertices = (PyArrayObject*)PyArray_FromObject`
`27`	`29`	`(vertices_obj.ptr(), PyArray_DOUBLE, 2, 2);`
`@@ -38,6 +40,7 @@ class PathIterator`
`38`	`40`	`throw Py::ValueError("Invalid codes array.");`
`39`	`41`	`}`
`40`	`42`
	`43`	`+ m_should_simplify = bool(Py::Int(should_simplify_obj));`
`41`	`44`	`m_total_vertices = m_vertices->dimensions[0];`
`42`	`45`	`}`
`43`	`46`
`@@ -100,9 +103,9 @@ class PathIterator`
`100`	`103`	`return m_total_vertices;`
`101`	`104`	`}`
`102`	`105`
`103`		`- inline bool has_curves()`
	`106`	`+ inline bool should_simplify()`
`104`	`107`	`{`
`105`		`- return m_codes;`
	`108`	`+ return m_should_simplify;`
`106`	`109`	`}`
`107`	`110`	`};`
`108`	`111`