matplotlib · tacaswell · Feb 18, 2016 · Dec 22, 2015 · Dec 22, 2015 · Dec 22, 2015
diff --git a/doc/api/api_changes/2015-12-30_draw_image.rst b/doc/api/api_changes/2015-12-30_draw_image.rst
@@ -0,0 +1,8 @@
+Change in the ``draw_image`` backend API
+----------------------------------------
+
+The ``draw_image`` method implemented by backends has changed its interface.
+
+This change is only relevant if the backend declares that it is able
+to transform images by returning ``True`` from ``option_scale_image``.
+See the ``draw_image`` docstring for more information.
diff --git a/doc/users/whats_new/2015-12-30_image-interpolation.rst b/doc/users/whats_new/2015-12-30_image-interpolation.rst
@@ -0,0 +1,18 @@
+Improved image support
+----------------------
+
+Prior to version 2.0, matplotlib resampled images by first applying
+the color map and then resizing the result.  Since the resampling was
+performed on the colored image, this introduced colors in the output
+image that didn't actually exist in the color map.  Now, images are
+resampled first (and entirely in floating-point, if the input image is
+floating-point), and then the color map is applied.
+
+In order to make this important change, the image handling code was
+almost entirely rewritten.  As a side effect, image resampling uses
+less memory and fewer datatype conversions than before.
+
+The experimental private feature where one could "skew" an image by
+setting the private member ``_image_skew_coordinate`` has been
+removed.  Instead, images will obey the transform of the axes on which
+they are drawn.
diff --git a/doc/users/whats_new/rcparams.rst b/doc/users/whats_new/rcparams.rst
@@ -19,10 +19,20 @@ Configuration (rcParams)
 |`svg.hashsalt`              | see note                                         |
 +----------------------------+--------------------------------------------------+
 
-``svg.hashsalt``
-````````````````
+Added ``svg.hashsalt`` key to rcParams
+```````````````````````````````````````
 
 If ``svg.hashsalt`` is ``None`` (which it is by default), the svg
 backend uses ``uuid4`` to generate the hash salt.  If it is not
 ``None``, it must be a string that is used as the hash salt instead of
 ``uuid4``.  This allows for deterministic SVG output.
+
+
+Removed the ``svg.image_noscale`` rcParam
+`````````````````````````````````````````
+
+As a result of the extensive changes to image handling, the
+``svg.image_noscale`` rcParam has been removed.  The same
+functionality may be achieved by setting ``interpolation='none'`` on
+individual images or globally using the ``image.interpolation``
+rcParam.
diff --git a/examples/api/demo_affine_image.py b/examples/api/demo_affine_image.py
@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-
-
 """
 For the backends that supports draw_image with optional affine
 transform (e.g., agg, ps backend), the image of the output should
@@ -24,22 +21,15 @@ def get_image():
     return Z
 
 
-def imshow_affine(ax, z, *kl, **kwargs):
-    im = ax.imshow(z, *kl, **kwargs)
-    x1, x2, y1, y2 = im.get_extent()
-    im._image_skew_coordinate = (x2, y1)
-    return im
-
-
 if 1:
 
     # image rotation
 
-    fig, (ax1, ax2) = plt.subplots(1, 2)
+    fig, ax1 = plt.subplots(1, 1)
     Z = get_image()
-    im1 = imshow_affine(ax1, Z, interpolation='none',
-                        origin='lower',
-                        extent=[-2, 4, -3, 2], clip_on=True)
+    im1 = ax1.imshow(Z, interpolation='none',
+                     origin='lower',
+                     extent=[-2, 4, -3, 2], clip_on=True)
 
     trans_data2 = mtransforms.Affine2D().rotate_deg(30) + ax1.transData
     im1.set_transform(trans_data2)
@@ -53,13 +43,3 @@ def imshow_affine(ax, z, *kl, **kwargs):
 
     ax1.set_xlim(-3, 5)
     ax1.set_ylim(-4, 4)
-
-    # image skew
-
-    im2 = ax2.imshow(Z, interpolation='none',
-                     origin='lower',
-                     extent=[-2, 4, -3, 2], clip_on=True)
-    im2._image_skew_coordinate = (3, -2)
-
-    plt.show()
-    #plt.savefig("demo_affine_image")
diff --git a/examples/images_contours_and_fields/interpolation_methods.py b/examples/images_contours_and_fields/interpolation_methods.py
@@ -18,6 +18,7 @@
            'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric',
            'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos']
 
+np.random.seed(0)
 grid = np.random.rand(4, 4)
 
 fig, axes = plt.subplots(3, 6, figsize=(12, 6),
@@ -26,7 +27,7 @@
 fig.subplots_adjust(hspace=0.3, wspace=0.05)
 
 for ax, interp_method in zip(axes.flat, methods):
-    ax.imshow(grid, interpolation=interp_method)
+    ax.imshow(grid, interpolation=interp_method, cmap='viridis')
     ax.set_title(interp_method)
 
 plt.show()
diff --git a/examples/pylab_examples/demo_annotation_box.py b/examples/pylab_examples/demo_annotation_box.py
@@ -48,6 +48,7 @@
 
     arr = np.arange(100).reshape((10, 10))
     im = OffsetImage(arr, zoom=2)
+    im.image.axes = ax
 
     ab = AnnotationBbox(im, xy,
                         xybox=(-50., 50.),
@@ -62,9 +63,10 @@
 
     from matplotlib._png import read_png
     fn = get_sample_data("grace_hopper.png", asfileobj=False)
-    arr_lena = read_png(fn)
+    arr_img = read_png(fn)
 
-    imagebox = OffsetImage(arr_lena, zoom=0.2)
+    imagebox = OffsetImage(arr_img, zoom=0.2)
+    imagebox.image.axes = ax
 
     ab = AnnotationBbox(imagebox, xy,
                         xybox=(120., -80.),

diff --git a/extern/agg24-svn/include/agg_span_image_filter_gray.h b/extern/agg24-svn/include/agg_span_image_filter_gray.h
@@ -490,7 +490,7 @@ namespace agg
                     fg_ptr = (const value_type*)base_type::source().next_y();
                 }
 
-                fg >>= image_filter_shift;
+                fg = color_type::downshift(fg, image_filter_shift);
                 if(fg < 0) fg = 0;
                 if(fg > color_type::full_value()) fg = color_type::full_value();
                 span->v = (value_type)fg;

diff --git a/lib/matplotlib/__init__.py b/lib/matplotlib/__init__.py
@@ -847,6 +847,7 @@ def matplotlib_fname():
     'savefig.extension': ('savefig.format', lambda x: x, None),
     'axes.color_cycle': ('axes.prop_cycle', lambda x: cycler('color', x),
                          lambda x: [c.get('color', None) for c in x]),
+    'svg.image_noscale': ('image.interpolation', None, None),
     }
 
 _deprecated_ignore_map = {

diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -2323,15 +2323,6 @@ def draw(self, renderer=None, inframe=False):
             artists.remove(self._left_title)
             artists.remove(self._right_title)
 
-        # add images to dsu if the backend supports compositing.
-        # otherwise, does the manual compositing  without adding images to dsu.
-        if len(self.images) <= 1 or renderer.option_image_nocomposite():
-            _do_composite = False
-        else:
-            _do_composite = True
-            for im in self.images:
-                artists.remove(im)
-
         if self.figure.canvas.is_saving():
             dsu = [(a.zorder, a) for a in artists]
         else:
@@ -2356,46 +2347,12 @@ def draw(self, renderer=None, inframe=False):
         if self.axison and self._frameon:
             self.patch.draw(renderer)
 
-        if _do_composite:
-            # make a composite image, blending alpha
-            # list of (mimage.Image, ox, oy)
-
-            zorder_images = [(im.zorder, im) for im in self.images
-                             if im.get_visible()]
-            zorder_images.sort(key=lambda x: x[0])
-
-            mag = renderer.get_image_magnification()
-            ims = [(im.make_image(mag), 0, 0, im.get_alpha())
-                   for z, im in zorder_images]
-
-            l, b, r, t = self.bbox.extents
-            width = int(mag * ((np.round(r) + 0.5) - (np.round(l) - 0.5)))
-            height = int(mag * ((np.round(t) + 0.5) - (np.round(b) - 0.5)))
-            im = mimage.from_images(height,
-                                    width,
-                                    ims)
-
-            im.is_grayscale = False
-            l, b, w, h = self.bbox.bounds
-            # composite images need special args so they will not
-            # respect z-order for now
-
-            gc = renderer.new_gc()
-            gc.set_clip_rectangle(self.bbox)
-            gc.set_clip_path(mtransforms.TransformedPath(
-                self.patch.get_path(),
-                self.patch.get_transform()))
-
-            renderer.draw_image(gc, round(l), round(b), im)
-            gc.restore()
-
         if dsu_rasterized:
             for zorder, a in dsu_rasterized:
                 a.draw(renderer)
             renderer.stop_rasterizing()
 
-        for zorder, a in dsu:
-            a.draw(renderer)
+        mimage._draw_list_compositing_images(renderer, self, dsu)
 
         renderer.close_group('axes')
         self._cachedRenderer = renderer

diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -515,7 +515,7 @@ def get_image_magnification(self):
         """
         return 1.0
 
-    def draw_image(self, gc, x, y, im):
+    def draw_image(self, gc, x, y, im, trans=None):
         """
         Draw the image instance into the current axes;
 
@@ -531,7 +531,14 @@ def draw_image(self, gc, x, y, im):
             is the distance from bottom
 
         *im*
-            the :class:`matplotlib._image.Image` instance
+            An NxMx4 array of RGBA pixels (of dtype uint8).
+
+        *trans*
+            If the concrete backend is written such that
+            `option_scale_image` returns `True`, an affine
+            transformation may also be passed to `draw_image`.  The
+            backend should apply the transformation to the image
+            before applying the translation of `x` and `y`.
         """
         raise NotImplementedError
 

diff --git a/lib/matplotlib/backends/backend_agg.py b/lib/matplotlib/backends/backend_agg.py
@@ -319,9 +319,9 @@ def option_image_nocomposite(self):
 
     def option_scale_image(self):
         """
-        agg backend support arbitrary scaling of image.
+        agg backend doesn't support arbitrary scaling of image.
         """
-        return True
+        return False
 
     def restore_region(self, region, bbox=None, xy=None):
         """
@@ -389,28 +389,25 @@ def post_processing(image, dpi):
         # For agg_filter to work, the rendere's method need
         # to overridden in the class. See draw_markers, and draw_path_collections
 
-        from matplotlib._image import fromarray
-
         width, height = int(self.width), int(self.height)
 
         buffer, bounds = self.tostring_rgba_minimized()
 
         l, b, w, h = bounds
 
-
         self._renderer = self._filter_renderers.pop()
         self._update_methods()
 
         if w > 0 and h > 0:
             img = np.fromstring(buffer, np.uint8)
             img, ox, oy = post_processing(img.reshape((h, w, 4)) / 255.,
                                           self.dpi)
-            image = fromarray(img, 1)
-
             gc = self.new_gc()
-            self._renderer.draw_image(gc,
-                                      l+ox, height - b - h +oy,
-                                      image)
+            if img.dtype.kind == 'f':
+                img = np.asarray(img * 255., np.uint8)
+            img = img[::-1]
+            self._renderer.draw_image(
+                gc, l + ox, height - b - h + oy, img)
 
 
 def new_figure_manager(num, *args, **kwargs):

diff --git a/lib/matplotlib/backends/backend_cairo.py b/lib/matplotlib/backends/backend_cairo.py
@@ -171,14 +171,18 @@ def draw_image(self, gc, x, y, im):
         # bbox - not currently used
         if _debug: print('%s.%s()' % (self.__class__.__name__, _fn_name()))
 
-        rows, cols, buf = im.color_conv (BYTE_FORMAT)
-        surface = cairo.ImageSurface.create_for_data (
-                      buf, cairo.FORMAT_ARGB32, cols, rows, cols*4)
+        if sys.byteorder == 'little':
+            im = im[:, :, (2, 1, 0, 3)]
+        else:
+            im = im[:, :, (3, 0, 1, 2)]
+        surface = cairo.ImageSurface.create_for_data(
+            memoryview(im.flatten()), cairo.FORMAT_ARGB32, im.shape[1], im.shape[0],
+            im.shape[1]*4)
         ctx = gc.ctx
-        y = self.height - y - rows
+        y = self.height - y - im.shape[0]
 
         ctx.save()
-        ctx.set_source_surface (surface, x, y)
+        ctx.set_source_surface(surface, float(x), float(y))
         if gc.get_alpha() != 1.0:
             ctx.paint_with_alpha(gc.get_alpha())
         else:

diff --git a/lib/matplotlib/backends/backend_gdk.py b/lib/matplotlib/backends/backend_gdk.py
@@ -109,17 +109,14 @@ def draw_image(self, gc, x, y, im):
             #             int(w), int(h))
             # set clip rect?
 
-        rows, cols, image_str = im.as_rgba_str()
-
-        image_array = np.fromstring(image_str, np.uint8)
-        image_array.shape = rows, cols, 4
+        rows, cols = im.shape[:2]
 
         pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
                                 has_alpha=True, bits_per_sample=8,
                                 width=cols, height=rows)
 
         array = pixbuf_get_pixels_array(pixbuf)
-        array[:,:,:] = image_array[::-1]
+        array[:, :, :] = im[::-1]
 
         gc = self.new_gc()
 

diff --git a/lib/matplotlib/backends/backend_mixed.py b/lib/matplotlib/backends/backend_mixed.py
@@ -1,9 +1,10 @@
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
 
+import numpy as np
+
 from matplotlib.externals import six
 
-from matplotlib._image import frombuffer
 from matplotlib.backends.backend_agg import RendererAgg
 from matplotlib.tight_bbox import process_figure_for_rasterizing
 
@@ -51,7 +52,7 @@ def __init__(self, figure, width, height, dpi, vector_renderer,
         # A reference to the figure is needed as we need to change
         # the figure dpi before and after the rasterization. Although
         # this looks ugly, I couldn't find a better solution. -JJL
-        self.figure=figure
+        self.figure = figure
         self._figdpi = figure.get_dpi()
 
         self._bbox_inches_restore = bbox_inches_restore
@@ -68,6 +69,7 @@ def __init__(self, figure, width, height, dpi, vector_renderer,
         draw_gouraud_triangles option_scale_image
         _text2path _get_text_path_transform height width
         """.split()
+
     def _set_current_renderer(self, renderer):
         self._renderer = renderer
 
@@ -90,7 +92,7 @@ def start_rasterizing(self):
         # change the dpi of the figure temporarily.
         self.figure.set_dpi(self.dpi)
 
-        if self._bbox_inches_restore: # when tight bbox is used
+        if self._bbox_inches_restore:  # when tight bbox is used
             r = process_figure_for_rasterizing(self.figure,
                                                self._bbox_inches_restore)
             self._bbox_inches_restore = r
@@ -114,12 +116,13 @@ def stop_rasterizing(self):
         if self._rasterizing == 0:
             self._set_current_renderer(self._vector_renderer)
 
-            width, height = self._width * self.dpi, self._height * self.dpi
+            height = self._height * self.dpi
             buffer, bounds = self._raster_renderer.tostring_rgba_minimized()
             l, b, w, h = bounds
             if w > 0 and h > 0:
-                image = frombuffer(buffer, w, h, True)
-                image.is_grayscale = False
+                image = np.frombuffer(buffer, dtype=np.uint8)
+                image = image.reshape((h, w, 4))
+                image = image[::-1]
                 gc = self._renderer.new_gc()
                 # TODO: If the mixedmode resolution differs from the figure's
                 #       dpi, the image must be scaled (dpi->_figdpi). Not all