def imshow(self, X, cmap=None, norm=None, aspect=None,<EOL>interpolation=None, alpha=<NUM_LIT:1.0>, vmin=None, vmax=None,<EOL>origin=None, extent=None, shape=None, filternorm=<NUM_LIT:1>,<EOL>filterrad=<NUM_LIT>, imlim=None, resample=None, url=None, **kwargs):
if not self._hold: self.cla()<EOL>if norm is not None: assert(isinstance(norm, mcolors.Normalize))<EOL>if cmap is not None: assert(isinstance(cmap, mcolors.Colormap))<EOL>if aspect is None: aspect = rcParams['<STR_LIT>']<EOL>self.set_aspect(aspect)<EOL>im = mimage.AxesImage(self, cmap, norm, interpolation, origin, extent,<EOL>filternorm=filternorm,<EOL>filterrad=filterrad, resample=resample, **kwargs)<EOL>im.set_data(X)<EOL>im.set_alpha(alpha)<EOL>self._set_artist_props(im)<EOL>im.set_clip_path(self.patch)<EOL>if vmin is not None or vmax is not None:<EOL><INDENT>im.set_clim(vmin, vmax)<EOL><DEDENT>else:<EOL><INDENT>im.autoscale_None()<EOL><DEDENT>im.set_url(url)<EOL>xmin, xmax, ymin, ymax = im.get_extent()<EOL>corners = (xmin, ymin), (xmax, ymax)<EOL>self.update_datalim(corners)<EOL>if self._autoscaleon:<EOL><INDENT>self.set_xlim((xmin, xmax))<EOL>self.set_ylim((ymin, ymax))<EOL><DEDENT>self.images.append(im)<EOL>return im<EOL>
call signature::

  imshow(X, cmap=None, norm=None, aspect=None, interpolation=None,
         alpha=1.0, vmin=None, vmax=None, origin=None, extent=None,
         **kwargs)

Display the image in *X* to current axes.  *X* may be a float
array, a uint8 array or a PIL image. If *X* is an array, *X*
can have the following shapes:

* MxN -- luminance (grayscale, float array only)
* MxNx3 -- RGB (float or uint8 array)
* MxNx4 -- RGBA (float or uint8 array)

The value for each component of MxNx3 and MxNx4 float arrays should be
in the range 0.0 to 1.0; MxN float arrays may be normalised.

An :class:`matplotlib.image.AxesImage` instance is returned.

Keyword arguments:

  *cmap*: [ None | Colormap ]
    A :class:`matplotlib.cm.Colormap` instance, eg. cm.jet.
    If *None*, default to rc ``image.cmap`` value.

    *cmap* is ignored when *X* has RGB(A) information

  *aspect*: [ None | 'auto' | 'equal' | scalar ]
    If 'auto', changes the image aspect ratio to match that of the axes

    If 'equal', and *extent* is *None*, changes the axes
    aspect ratio to match that of the image. If *extent* is
    not *None*, the axes aspect ratio is changed to match that
    of the extent.

    If *None*, default to rc ``image.aspect`` value.

  *interpolation*:

    Acceptable values are *None*, 'nearest', 'bilinear',
      'bicubic', 'spline16', 'spline36', 'hanning', 'hamming',
      'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian',
      'bessel', 'mitchell', 'sinc', 'lanczos',


    If *interpolation* is *None*, default to rc
    ``image.interpolation``. See also the *filternorm* and
    *filterrad* parameters

  *norm*: [ None | Normalize ]
    An :class:`matplotlib.colors.Normalize` instance; if
    *None*, default is ``normalization()``.  This scales
    luminance -> 0-1

    *norm* is only used for an MxN float array.

  *vmin*/*vmax*: [ None | scalar ]
    Used to scale a luminance image to 0-1.  If either is
    *None*, the min and max of the luminance values will be
    used.  Note if *norm* is not *None*, the settings for
    *vmin* and *vmax* will be ignored.

  *alpha*: scalar
    The alpha blending value, between 0 (transparent) and 1 (opaque)

  *origin*: [ None | 'upper' | 'lower' ]
    Place the [0,0] index of the array in the upper left or lower left
    corner of the axes. If *None*, default to rc ``image.origin``.

  *extent*: [ None | scalars (left, right, bottom, top) ]
    Eata values of the axes.  The default assigns zero-based row,
    column indices to the *x*, *y* centers of the pixels.

  *shape*: [ None | scalars (columns, rows) ]
    For raw buffer images

  *filternorm*:
    A parameter for the antigrain image resize filter.  From the
    antigrain documentation, if *filternorm* = 1, the filter normalizes
    integer values and corrects the rounding errors. It doesn't do
    anything with the source floating point values, it corrects only
    integers according to the rule of 1.0 which means that any sum of
    pixel weights must be equal to 1.0.  So, the filter function must
    produce a graph of the proper shape.

  *filterrad*:
    The filter radius for filters that have a radius
    parameter, i.e. when interpolation is one of: 'sinc',
    'lanczos' or 'blackman'

Additional kwargs are :class:`~matplotlib.artist.Artist` properties:

%(Artist)s

**Example:**

.. plot:: mpl_examples/pylab_examples/image_demo.py