backend driver fix

svn path=/trunk/matplotlib/; revision=5165

Author: jdh2358

Makefile

@@ -15,7 +15,6 @@ clean:
 	rm -f *.png *.ps *.eps *.svg *.jpg *.pdf
 	find . -name "_tmp*.py" | xargs rm -f;\
 	find . \( -name "*~" -o -name "*.pyc" \) | xargs rm -f;\
-	find examples \( -name "*.svg" C-o -name "*.png" -o -name "*.pdf" -o -name "*.ps"  -o -name "*.eps" -o -name "*.tar" -o  -name "*.gz" -o -name "*.log" -o -name "*.aux" -o -name "*.tex" \) | xargs rm -f
 	find unit \( -name "*.png" -o -name "*.ps"  -o -name "*.pdf" -o -name "*.eps" \) | xargs rm -f
 	find . \( -name "#*" -o -name ".#*" -o -name ".*~" -o -name "*~" \) | xargs rm -f
 

examples/pylab/agg_buffer_to_array.py

@@ -1,7 +1,7 @@
 import matplotlib
 matplotlib.use('Agg')
 from pylab import figure, show
-import numpy as npy
+import numpy as np
 
 # make an agg figure
 fig = figure()
@@ -13,7 +13,7 @@
 # grab rhe pixel buffer and dumpy it into a numpy array
 buf = fig.canvas.buffer_rgba(0,0)
 l, b, w, h = fig.bbox.bounds
-X = npy.fromstring(buf, npy.uint8)
+X = np.fromstring(buf, np.uint8)
 X.shape = h,w,4
 
 # now display the array X as an Axes in a new figure

examples/pylab/annotation_demo.py

@@ -35,7 +35,7 @@
 
 from matplotlib.pyplot import figure, show
 from matplotlib.patches import Ellipse
-import numpy as npy
+import numpy as np
 
 
 if 1:
@@ -44,8 +44,8 @@
     fig = figure()
     ax = fig.add_subplot(111, autoscale_on=False, xlim=(-1,5), ylim=(-3,5))
 
-    t = npy.arange(0.0, 5.0, 0.01)
-    s = npy.cos(2*npy.pi*t)
+    t = np.arange(0.0, 5.0, 0.01)
+    s = np.cos(2*np.pi*t)
     line, = ax.plot(t, s, lw=3, color='purple')
 
     ax.annotate('axes center', xy=(.5, .5),  xycoords='axes fraction',
@@ -94,8 +94,8 @@
     # respected
     fig = figure()
     ax = fig.add_subplot(111, polar=True)
-    r = npy.arange(0,1,0.001)
-    theta = 2*2*npy.pi*r
+    r = np.arange(0,1,0.001)
+    theta = 2*2*np.pi*r
     line, = ax.plot(theta, r, color='#ee8d18', lw=3)
 
     ind = 800
@@ -124,8 +124,8 @@
     ax.add_artist(el)
     el.set_clip_box(ax.bbox)
     ax.annotate('the top',
-                xy=(npy.pi/2., 10.),      # theta, radius
-                xytext=(npy.pi/3, 20.),   # theta, radius
+                xy=(np.pi/2., 10.),      # theta, radius
+                xytext=(np.pi/3, 20.),   # theta, radius
                 xycoords='polar',
                 textcoords='polar',
                 arrowprops=dict(facecolor='black', shrink=0.05),

examples/pylab/clippedline.py

@@ -4,7 +4,7 @@
 """
 
 from matplotlib.lines import Line2D
-import numpy as npy
+import numpy as np
 from pylab import figure, show
 
 class ClippedLine(Line2D):
@@ -19,13 +19,13 @@ def __init__(self, ax, *args, **kwargs):
 
     def set_data(self, *args, **kwargs):
         Line2D.set_data(self, *args, **kwargs)
-        self.xorig = npy.array(self._x)
-        self.yorig = npy.array(self._y)
+        self.xorig = np.array(self._x)
+        self.yorig = np.array(self._y)
 
     def draw(self, renderer):
         xlim = self.ax.get_xlim()
 
-        ind0, ind1 = npy.searchsorted(self.xorig, xlim)
+        ind0, ind1 = np.searchsorted(self.xorig, xlim)
         self._x = self.xorig[ind0:ind1]
         self._y = self.yorig[ind0:ind1]
         N = len(self._x)
@@ -43,8 +43,8 @@ def draw(self, renderer):
 fig = figure()
 ax = fig.add_subplot(111, autoscale_on=False)
 
-t = npy.arange(0.0, 100.0, 0.01)
-s = npy.sin(2*npy.pi*t)
+t = np.arange(0.0, 100.0, 0.01)
+s = np.sin(2*np.pi*t)
 line = ClippedLine(ax, t, s, color='g', ls='-', lw=2)
 ax.add_line(line)
 ax.set_xlim(10,30)

examples/pylab/colours.py

@@ -2,12 +2,12 @@
 """
 Some simple functions to generate colours.
 """
-import numpy as npy
+import numpy as np
 from matplotlib.colors import colorConverter
 
 def pastel(colour, weight=2.4):
     """ Convert colour into a nice pastel shade"""
-    rgb = npy.asarray(colorConverter.to_rgb(colour))
+    rgb = np.asarray(colorConverter.to_rgb(colour))
     # scale colour
     maxc = max(rgb)
     if maxc < 1.0 and maxc > 0:
@@ -31,7 +31,7 @@ def pastel(colour, weight=2.4):
 
 def get_colours(n):
     """ Return n pastel colours. """
-    base = npy.asarray([[1,0,0], [0,1,0], [0,0,1]])
+    base = np.asarray([[1,0,0], [0,1,0], [0,0,1]])
 
     if n <= 3:
         return base[0:n]
@@ -42,7 +42,7 @@ def get_colours(n):
 
     colours = []
     for start in (0, 1):
-        for x in npy.linspace(0, 1, needed[start]+2):
+        for x in np.linspace(0, 1, needed[start]+2):
             colours.append((base[start] * (1.0 - x)) +
                            (base[start+1] * x))
 

examples/pylab/contourf_log.py

@@ -3,16 +3,16 @@
 '''
 
 from matplotlib import pyplot as P
-import numpy as npy
+import numpy as np
 from numpy import ma
 from matplotlib import colors, ticker
 from matplotlib.mlab import bivariate_normal
 
 N = 100
-x = npy.linspace(-3.0, 3.0, N)
-y = npy.linspace(-2.0, 2.0, N)
+x = np.linspace(-3.0, 3.0, N)
+y = np.linspace(-2.0, 2.0, N)
 
-X, Y = npy.meshgrid(x, y)
+X, Y = np.meshgrid(x, y)
 
 # A low hump with a spike coming out of the top right.
 # Needs to have z/colour axis on a log scale so we see both hump and spike.
@@ -34,9 +34,9 @@
 
 # Alternatively, you can manually set the levels
 # and the norm:
-#lev_exp = npy.arange(npy.floor(npy.log10(z.min())-1),
-#                       npy.ceil(npy.log10(z.max())+1))
-#levs = npy.power(10, lev_exp)
+#lev_exp = np.arange(np.floor(np.log10(z.min())-1),
+#                       np.ceil(np.log10(z.max())+1))
+#levs = np.power(10, lev_exp)
 #cs = P.contourf(X, Y, z, levs, norm=colors.LogNorm())
 
 #The 'extend' kwarg does not work yet with a log scale.

examples/pylab/custom_projection_example.py

@@ -7,7 +7,7 @@
     BboxTransformTo, IdentityTransform, Transform, TransformWrapper
 from matplotlib.projections import register_projection
 
-import numpy as npy
+import numpy as np
 
 # This example projection class is rather long, but it is designed to
 # illustrate many features, not all of which will be used every time.
@@ -60,8 +60,8 @@ def cla(self):
         # be changed by the user.  This makes the math in the
         # transformation itself easier, and since this is a toy
         # example, the easier, the better.
-        Axes.set_xlim(self, -npy.pi, npy.pi)
-        Axes.set_ylim(self, -npy.pi / 2.0, npy.pi / 2.0)
+        Axes.set_xlim(self, -np.pi, np.pi)
+        Axes.set_ylim(self, -np.pi / 2.0, np.pi / 2.0)
 
     def cla(self):
         """
@@ -79,8 +79,8 @@ def cla(self):
 
         # self.grid(rcParams['axes.grid'])
 
-        Axes.set_xlim(self, -npy.pi, npy.pi)
-        Axes.set_ylim(self, -npy.pi / 2.0, npy.pi / 2.0)
+        Axes.set_xlim(self, -np.pi, np.pi)
+        Axes.set_ylim(self, -np.pi / 2.0, np.pi / 2.0)
 
     def _set_lim_and_transforms(self):
         """
@@ -117,8 +117,8 @@ def _set_lim_and_transforms(self):
         # within the axes.  The peculiar calculations of xscale and
         # yscale are specific to a Aitoff-Hammer projection, so don't
         # worry about them too much.
-        xscale = 2.0 * npy.sqrt(2.0) * npy.sin(0.5 * npy.pi)
-        yscale = npy.sqrt(2.0) * npy.sin(0.5 * npy.pi)
+        xscale = 2.0 * np.sqrt(2.0) * np.sin(0.5 * np.pi)
+        yscale = np.sqrt(2.0) * np.sin(0.5 * np.pi)
         self.transAffine = Affine2D() \
             .scale(0.5 / xscale, 0.5 / yscale) \
             .translate(0.5, 0.5)
@@ -148,8 +148,8 @@ def _set_lim_and_transforms(self):
         # pixels from the equator.
         self._xaxis_pretransform = \
             Affine2D() \
-            .scale(1.0, npy.pi) \
-            .translate(0.0, -npy.pi)
+            .scale(1.0, np.pi) \
+            .translate(0.0, -np.pi)
         self._xaxis_transform = \
             self._xaxis_pretransform + \
             self.transData
@@ -168,7 +168,7 @@ def _set_lim_and_transforms(self):
         # (1, ymax).  The goal of these transforms is to go from that
         # space to display space.  The tick labels will be offset 4
         # pixels from the edge of the axes ellipse.
-        yaxis_stretch = Affine2D().scale(npy.pi * 2.0, 1.0).translate(-npy.pi, 0.0)
+        yaxis_stretch = Affine2D().scale(np.pi * 2.0, 1.0).translate(-np.pi, 0.0)
         yaxis_space = Affine2D().scale(1.0, 1.1)
         self._yaxis_transform = \
             yaxis_stretch + \
@@ -265,8 +265,8 @@ def set_yscale(self, *args, **kwargs):
     # set_xlim and set_ylim to ignore any input.  This also applies to
     # interactive panning and zooming in the GUI interfaces.
     def set_xlim(self, *args, **kwargs):
-        Axes.set_xlim(self, -npy.pi, npy.pi)
-        Axes.set_ylim(self, -npy.pi / 2.0, npy.pi / 2.0)
+        Axes.set_xlim(self, -np.pi, np.pi)
+        Axes.set_ylim(self, -np.pi / 2.0, np.pi / 2.0)
     set_ylim = set_xlim
 
     def format_coord(self, long, lat):
@@ -276,8 +276,8 @@ def format_coord(self, long, lat):
 
         In this case, we want them to be displayed in degrees N/S/E/W.
         """
-        long = long * (180.0 / npy.pi)
-        lat = lat * (180.0 / npy.pi)
+        long = long * (180.0 / np.pi)
+        lat = lat * (180.0 / np.pi)
         if lat >= 0.0:
             ns = 'N'
         else:
@@ -298,7 +298,7 @@ def __init__(self, round_to=1.0):
             self._round_to = round_to
 
         def __call__(self, x, pos=None):
-            degrees = (x / npy.pi) * 180.0
+            degrees = (x / np.pi) * 180.0
             degrees = round(degrees / self._round_to) * self._round_to
             # \u00b0 : degree symbol
             return u"%d\u00b0" % degrees
@@ -316,7 +316,7 @@ class -- it provides a more convenient interface to set the
         number = (360.0 / degrees) + 1
         self.xaxis.set_major_locator(
             FixedLocator(
-                npy.linspace(-npy.pi, npy.pi, number, True)[1:-1]))
+                np.linspace(-np.pi, np.pi, number, True)[1:-1]))
         # Set the formatter to display the tick labels in degrees,
         # rather than radians.
         self.xaxis.set_major_formatter(self.DegreeFormatter(degrees))
@@ -334,7 +334,7 @@ class -- it provides a more convenient interface than
         number = (180.0 / degrees) + 1
         self.yaxis.set_major_locator(
             FixedLocator(
-                npy.linspace(-npy.pi / 2.0, npy.pi / 2.0, number, True)[1:-1]))
+                np.linspace(-np.pi / 2.0, np.pi / 2.0, number, True)[1:-1]))
         # Set the formatter to display the tick labels in degrees,
         # rather than radians.
         self.yaxis.set_major_formatter(self.DegreeFormatter(degrees))
@@ -351,7 +351,7 @@ def set_longitude_grid_ends(self, degrees):
         class -- it provides an interface to something that has no
         analogy in the base Axes class.
         """
-        longitude_cap = degrees * (npy.pi / 180.0)
+        longitude_cap = degrees * (np.pi / 180.0)
         # Change the xaxis gridlines transform so that it draws from
         # -degrees to degrees, rather than -pi to pi.
         self._xaxis_pretransform \
@@ -412,13 +412,13 @@ def transform(self, ll):
 
             # Pre-compute some values
             half_long = longitude / 2.0
-            cos_latitude = npy.cos(latitude)
-            sqrt2 = npy.sqrt(2.0)
+            cos_latitude = np.cos(latitude)
+            sqrt2 = np.sqrt(2.0)
 
-            alpha = 1.0 + cos_latitude * npy.cos(half_long)
-            x = (2.0 * sqrt2) * (cos_latitude * npy.sin(half_long)) / alpha
-            y = (sqrt2 * npy.sin(latitude)) / alpha
-            return npy.concatenate((x, y), 1)
+            alpha = 1.0 + cos_latitude * np.cos(half_long)
+            x = (2.0 * sqrt2) * (cos_latitude * np.sin(half_long)) / alpha
+            y = (sqrt2 * np.sin(latitude)) / alpha
+            return np.concatenate((x, y), 1)
 
         # This is where things get interesting.  With this projection,
         # straight lines in data space become curves in display space.
@@ -451,10 +451,10 @@ def transform(self, xy):
 
             quarter_x = 0.25 * x
             half_y = 0.5 * y
-            z = npy.sqrt(1.0 - quarter_x*quarter_x - half_y*half_y)
-            longitude = 2 * npy.arctan((z*x) / (2.0 * (2.0*z*z - 1.0)))
-            latitude = npy.arcsin(y*z)
-            return npy.concatenate((longitude, latitude), 1)
+            z = np.sqrt(1.0 - quarter_x*quarter_x - half_y*half_y)
+            longitude = 2 * np.arctan((z*x) / (2.0 * (2.0*z*z - 1.0)))
+            latitude = np.arcsin(y*z)
+            return np.concatenate((longitude, latitude), 1)
         transform.__doc__ = Transform.transform.__doc__
 
         def inverted(self):

examples/pylab/custom_scale_example.py

@@ -36,8 +36,8 @@ def __init__(self, axis, **kwargs):
         thresh: The degree above which to crop the data.
         """
         mscale.ScaleBase.__init__(self)
-        thresh = kwargs.pop("thresh", (85 / 180.0) * npy.pi)
-        if thresh >= npy.pi / 2.0:
+        thresh = kwargs.pop("thresh", (85 / 180.0) * np.pi)
+        if thresh >= np.pi / 2.0:
             raise ValueError("thresh must be less than pi/2")
         self.thresh = thresh
 
@@ -67,11 +67,11 @@ def set_default_locators_and_formatters(self, axis):
         class DegreeFormatter(Formatter):
             def __call__(self, x, pos=None):
                 # \u00b0 : degree symbol
-                return u"%d\u00b0" % ((x / npy.pi) * 180.0)
+                return u"%d\u00b0" % ((x / np.pi) * 180.0)
 
-        deg2rad = npy.pi / 180.0
+        deg2rad = np.pi / 180.0
         axis.set_major_locator(FixedLocator(
-                npy.arange(-90, 90, 10) * deg2rad))
+                np.arange(-90, 90, 10) * deg2rad))
         axis.set_major_formatter(DegreeFormatter())
         axis.set_minor_formatter(DegreeFormatter())
 
@@ -118,9 +118,9 @@ def transform(self, a):
             """
             masked = ma.masked_where((a < -self.thresh) | (a > self.thresh), a)
             if masked.mask.any():
-                return ma.log(npy.abs(ma.tan(masked) + 1.0 / ma.cos(masked)))
+                return ma.log(np.abs(ma.tan(masked) + 1.0 / ma.cos(masked)))
             else:
-                return npy.log(npy.abs(npy.tan(a) + 1.0 / npy.cos(a)))
+                return np.log(np.abs(np.tan(a) + 1.0 / np.cos(a)))
 
         def inverted(self):
             """
@@ -139,7 +139,7 @@ def __init__(self, thresh):
             self.thresh = thresh
 
         def transform(self, a):
-            return npy.arctan(npy.sinh(a))
+            return np.arctan(np.sinh(a))
 
         def inverted(self):
             return MercatorLatitudeScale.MercatorLatitudeTransform(self.thresh)
@@ -149,10 +149,10 @@ def inverted(self):
 mscale.register_scale(MercatorLatitudeScale)
 
 from pylab import *
-import numpy as npy
+import numpy as np
 
 t = arange(-180.0, 180.0, 0.1)
-s = t / 360.0 * npy.pi
+s = t / 360.0 * np.pi
 
 plot(t, s, '-', lw=2)
 gca().set_yscale('mercator')