Merge pull request matplotlib#746 from mdboom/nxutils_backward

Provide backward-compatible nxutils

Author: WeatherGod

Diff for: examples/event_handling/lasso_demo.py

@@ -4,29 +4,28 @@
 selected points
 
 This is currently a proof-of-concept implementation (though it is
-usable as is).  There will be some refinement of the API and the
-inside polygon detection routine.
+usable as is).  There will be some refinement of the API.
 """
 from matplotlib.widgets import Lasso
-from matplotlib.nxutils import points_inside_poly
 from matplotlib.colors import colorConverter
 from matplotlib.collections import RegularPolyCollection
+from matplotlib import path
 
-from matplotlib.pyplot import figure, show
+import matplotlib.pyplot as plt
 from numpy import nonzero
 from numpy.random import rand
 
-class Datum:
+class Datum(object):
     colorin = colorConverter.to_rgba('red')
-    colorout = colorConverter.to_rgba('green')
+    colorout = colorConverter.to_rgba('blue')
     def __init__(self, x, y, include=False):
         self.x = x
         self.y = y
         if include: self.color = self.colorin
         else: self.color = self.colorout
 
 
-class LassoManager:
+class LassoManager(object):
     def __init__(self, ax, data):
         self.axes = ax
         self.canvas = ax.figure.canvas
@@ -46,21 +45,21 @@ def __init__(self, ax, data):
         ax.add_collection(self.collection)
 
         self.cid = self.canvas.mpl_connect('button_press_event', self.onpress)
-        self.ind = None
 
     def callback(self, verts):
         facecolors = self.collection.get_facecolors()
-        ind = nonzero(points_inside_poly(self.xys, verts))[0]
-        for i in range(self.Nxy):
-            if i in ind:
+        p = path.Path(verts)
+        ind = p.contains_points(self.xys)
+        for i in range(len(self.xys)):
+            if ind[i]:
                 facecolors[i] = Datum.colorin
             else:
                 facecolors[i] = Datum.colorout
 
         self.canvas.draw_idle()
         self.canvas.widgetlock.release(self.lasso)
         del self.lasso
-        self.ind = ind
+
     def onpress(self, event):
         if self.canvas.widgetlock.locked(): return
         if event.inaxes is None: return
@@ -72,8 +71,7 @@ def onpress(self, event):
 
     data = [Datum(*xy) for xy in rand(100, 2)]
 
-    fig = figure()
-    ax = fig.add_subplot(111, xlim=(0,1), ylim=(0,1), autoscale_on=False)
+    ax = plt.axes(xlim=(0,1), ylim=(0,1), autoscale_on=False)
     lman = LassoManager(ax, data)
 
-    show()
+    plt.show()

Diff for: lib/matplotlib/nxutils.py

@@ -0,0 +1,50 @@
+import warnings
+
+from matplotlib import path
+
+def pnpoly(x, y, xyverts):
+    """
+    inside = pnpoly(x, y, xyverts)
+
+    Return 1 if x,y is inside the polygon, 0 otherwise.
+
+    *xyverts*
+        a sequence of x,y vertices.
+
+    A point on the boundary may be treated as inside or outside.
+
+    .. deprecated:: 1.2.0
+        Use :meth:`~matplotlib.path.Path.contains_point` instead.
+    """
+    warings.warn(
+        "nxutils is deprecated.  Use matplotlib.path.Path.contains_point"
+        " instead.",
+        DeprecationWarning)
+
+    p = path.Path(xyverts)
+    return p.contains_point(x, y)
+
+def points_inside_poly(xypoints, xyverts):
+    """
+    mask = points_inside_poly(xypoints, xyverts)
+
+    Returns a boolean ndarray, True for points inside the polygon.
+
+    *xypoints*
+        a sequence of N x,y pairs.
+
+    *xyverts*
+        sequence of x,y vertices of the polygon.
+
+    A point on the boundary may be treated as inside or outside.
+
+    .. deprecated:: 1.2.0
+        Use :meth:`~matplotlib.path.Path.contains_points` instead.
+    """
+    warnings.warn(
+        "nxutils is deprecated.  Use matplotlib.path.Path.contains_points"
+        " instead.",
+        DeprecationWarning)
+
+    p = path.Path(xyverts)
+    return p.contains_points(xypoints)

Diff for: lib/matplotlib/path.py

@@ -12,7 +12,7 @@
 from matplotlib._path import point_in_path, get_path_extents, \
     point_in_path_collection, get_path_collection_extents, \
     path_in_path, path_intersects_path, convert_path_to_polygons, \
-    cleanup_path
+    cleanup_path, points_in_path
 from matplotlib.cbook import simple_linear_interpolation, maxdict
 from matplotlib import rcParams
 
@@ -280,12 +280,31 @@ def contains_point(self, point, transform=None, radius=0.0):
 
         If *transform* is not *None*, the path will be transformed
         before performing the test.
+
+        *radius* allows the path to be made slightly larger or
+        smaller.
         """
         if transform is not None:
             transform = transform.frozen()
         result = point_in_path(point[0], point[1], radius, self, transform)
         return result
 
+    def contains_points(self, points, transform=None, radius=0.0):
+        """
+        Returns a bool array which is *True* if the path contains the
+        corresponding point.
+
+        If *transform* is not *None*, the path will be transformed
+        before performing the test.
+
+        *radius* allows the path to be made slightly larger or
+        smaller.
+        """
+        if transform is not None:
+            transform = transform.frozen()
+        result = points_in_path(points, radius, self, transform)
+        return result
+
     def contains_path(self, path, transform=None):
         """
         Returns *True* if this path completely contains the given path.