Merge upstream master.

Author: maxalbert

lib/matplotlib/figure.py

@@ -785,8 +785,14 @@ def fixitems(items):
             # to tuples for the key
             ret = []
             for k, v in items:
-                if iterable(v):
+                # some objects can define __getitem__ without being
+                # iterable and in those cases the conversion to tuples
+                # will fail. So instead of using the iterable(v) function
+                # we simply try and convert to a tuple, and proceed if not.
+                try:
                     v = tuple(v)
+                except Exception:
+                    pass
                 ret.append((k, v))
             return tuple(ret)
 

lib/matplotlib/image.py

@@ -574,6 +574,11 @@ def __init__(self, ax,
                                 **kwargs
                                 )
 
+    def get_window_extent(self, renderer=None):
+        x0, x1, y0, y1 = self._extent
+        bbox = Bbox.from_extents([x0, y0, x1, y1])
+        return bbox.transformed(self.axes.transData)
+
     def make_image(self, magnification=1.0):
         if self._A is None:
             raise RuntimeError('You must first set the image'

lib/matplotlib/tests/test_figure.py

@@ -6,6 +6,7 @@
 
 from nose.tools import assert_equal, assert_true, assert_raises
 from matplotlib.testing.decorators import image_comparison, cleanup
+from matplotlib.axes import Axes
 import matplotlib.pyplot as plt
 
 
@@ -110,6 +111,36 @@ def test_too_many_figures():
     assert len(w) == 1
 
 
+def test_iterability_axes_argument():
+
+    # This is a regression test for matplotlib/matplotlib#3196. If one of the
+    # arguments returned by _as_mpl_axes defines __getitem__ but is not
+    # iterable, this would raise an execption. This is because we check
+    # whether the arguments are iterable, and if so we try and convert them
+    # to a tuple. However, the ``iterable`` function returns True if
+    # __getitem__ is present, but some classes can define __getitem__ without
+    # being iterable. The tuple conversion is now done in a try...except in
+    # case it fails.
+
+    class MyAxes(Axes):
+        def __init__(self, *args, **kwargs):
+            kwargs.pop('myclass', None)
+            return Axes.__init__(self, *args, **kwargs)
+
+    class MyClass(object):
+
+        def __getitem__(self, item):
+            if item != 'a':
+                raise ValueError("item should be a")
+
+        def _as_mpl_axes(self):
+            return MyAxes, {'myclass': self}
+
+    fig = plt.figure()
+    ax = fig.add_subplot(1, 1, 1, projection=MyClass())
+    plt.close(fig)
+
+
 if __name__ == "__main__":
     import nose
     nose.runmodule(argv=['-s', '--with-doctest'], exit=False)

lib/matplotlib/tests/test_image.py

@@ -335,6 +335,28 @@ def test_bbox_image_inverted():
     axes.add_artist(bbox_im)
 
 
+@cleanup
+def test_get_window_extent_for_AxisImage():
+    # Create a figure of known size (1000x1000 pixels), place an image
+    # object at a given location and check that get_window_extent()
+    # returns the correct bounding box values (in pixels).
+
+    im = np.array([[0.25, 0.75, 1.0, 0.75], [0.1, 0.65, 0.5, 0.4], \
+        [0.6, 0.3, 0.0, 0.2], [0.7, 0.9, 0.4, 0.6]])
+    fig = plt.figure(figsize=(10, 10), dpi=100)
+    ax = plt.subplot()
+    ax.set_position([0, 0, 1, 1])
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    im_obj = ax.imshow(im, extent=[0.4, 0.7, 0.2, 0.9], interpolation='nearest')
+
+    fig.canvas.draw()
+    renderer = fig.canvas.renderer
+    im_bbox = im_obj.get_window_extent(renderer)
+
+    assert_array_equal(im_bbox.get_points(), [[400, 200], [700, 900]])
+
+
 if __name__=='__main__':
     import nose
     nose.runmodule(argv=['-s','--with-doctest'], exit=False)

lib/matplotlib/tests/test_transforms.py

@@ -487,6 +487,12 @@ def test_bbox_as_strings():
         assert_equal(eval(format(getattr(b, k), fmt)), v)
 
 
+def test_transform_single_point():
+    t = mtrans.Affine2D()
+    r = t.transform_affine((1, 1))
+    assert r.shape == (2,)
+
+
 @cleanup
 def test_log_transform():
     # Tests that the last line runs without exception (previously the

src/_path.h

@@ -687,7 +687,7 @@ clip_path_to_rect(PathIterator &path, agg::rect_d &rect, bool inside, std::vecto
 }
 
 template <class VerticesArray, class ResultArray>
-void affine_transform(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)
+void affine_transform_2d(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)
 {
     if (vertices.dim(0) != 0 && vertices.dim(1) != 2) {
         throw "Invalid vertices array.";
@@ -716,6 +716,33 @@ void affine_transform(VerticesArray &vertices, agg::trans_affine &trans, ResultA
     }
 }
 
+template <class VerticesArray, class ResultArray>
+void affine_transform_1d(VerticesArray &vertices, agg::trans_affine &trans, ResultArray &result)
+{
+    if (vertices.dim(0) != 2) {
+        throw "Invalid vertices array.";
+    }
+
+    double x;
+    double y;
+    double t0;
+    double t1;
+    double t;
+
+    x = vertices(0);
+    y = vertices(1);
+
+    t0 = trans.sx * x;
+    t1 = trans.shx * y;
+    t = t0 + t1 + trans.tx;
+    result(0) = t;
+
+    t0 = trans.shy * x;
+    t1 = trans.sy * y;
+    t = t0 + t1 + trans.ty;
+    result(1) = t;
+}
+
 template <class BBoxArray>
 int count_bboxes_overlapping_bbox(agg::rect_d &a, BBoxArray &bboxes)
 {

src/_path_wrapper.cpp

@@ -419,24 +419,30 @@ const char *Py_affine_transform__doc__ = "affine_transform(points, trans)";
 
 static PyObject *Py_affine_transform(PyObject *self, PyObject *args, PyObject *kwds)
 {
-    numpy::array_view<const double, 2> vertices;
+    PyObject *vertices_obj;
     agg::trans_affine trans;
 
     if (!PyArg_ParseTuple(args,
-                          "O&O&:affine_transform",
-                          &vertices.converter,
-                          &vertices,
+                          "OO&:affine_transform",
+                          &vertices_obj,
                           &convert_trans_affine,
                           &trans)) {
         return NULL;
     }
 
-    npy_intp dims[] = { vertices.dim(0), 2 };
-    numpy::array_view<double, 2> result(dims);
-
-    CALL_CPP("affine_transform", (affine_transform(vertices, trans, result)));
-
-    return result.pyobj();
+    try {
+        numpy::array_view<double, 2> vertices(vertices_obj);
+        npy_intp dims[] = { vertices.dim(0), 2 };
+        numpy::array_view<double, 2> result(dims);
+        CALL_CPP("affine_transform", (affine_transform_2d(vertices, trans, result)));
+        return result.pyobj();
+    } catch (py::exception) {
+        numpy::array_view<double, 1> vertices(vertices_obj);
+        npy_intp dims[] = { vertices.dim(0) };
+        numpy::array_view<double, 1> result(dims);
+        CALL_CPP("affine_transform", (affine_transform_1d(vertices, trans, result)));
+        return result.pyobj();
+    }
 }
 
 const char *Py_count_bboxes_overlapping_bbox__doc__ = "count_bboxes_overlapping_bbox(bbox, bboxes)";

src/ft2font_wrapper.cpp

@@ -1311,7 +1311,7 @@ static PyObject *PyFT2Font_get_sfnt_table(PyFT2Font *self, PyObject *args, PyObj
     case 6: {
         #if PY3K
         char pclt_dict[] =
-            "{s:(h,h), s:k, s:H, s:H, s:H, s:H, s:H, s:H, s:s, s:y, s:b, s:b, "
+            "{s:(h,h), s:k, s:H, s:H, s:H, s:H, s:H, s:H, s:y, s:y, s:b, s:b, "
             "s:b}";
         #else
         char pclt_dict[] =