misc.pilutil

A collection of image utilities using the Python Imaging Library (PIL).

Note that PIL is not a dependency of SciPy and this module is not available on systems that don’t have PIL installed.

Module Contents

Functions

bytescale(data,cmin=None,cmax=None,high=255,low=0) Byte scales an array (image).
imread(name,flatten=False,mode=None) Read an image from a file as an array.
imsave(name,arr,format=None) Save an array as an image.
fromimage(im,flatten=False,mode=None) Return a copy of a PIL image as a numpy array.
toimage(arr,high=255,low=0,cmin=None,cmax=None,pal=None,mode=None,channel_axis=None) Takes a numpy array and returns a PIL image.
imrotate(arr,angle,interp=”bilinear”) Rotate an image counter-clockwise by angle degrees.
imshow(arr) Simple showing of an image through an external viewer.
imresize(arr,size,interp=”bilinear”,mode=None) Resize an image.
imfilter(arr,ftype) Simple filtering of an image.
bytescale(data, cmin=None, cmax=None, high=255, low=0)

Byte scales an array (image).

Byte scaling means converting the input image to uint8 dtype and scaling the range to (low, high) (default 0-255). If the input image already has dtype uint8, no scaling is done.

This function is only available if Python Imaging Library (PIL) is installed.

data : ndarray
PIL image data array.
cmin : scalar, optional
Bias scaling of small values. Default is data.min().
cmax : scalar, optional
Bias scaling of large values. Default is data.max().
high : scalar, optional
Scale max value to high. Default is 255.
low : scalar, optional
Scale min value to low. Default is 0.
img_array : uint8 ndarray
The byte-scaled array.
>>> from scipy.misc import bytescale
>>> img = np.array([[ 91.06794177,   3.39058326,  84.4221549 ],
...                 [ 73.88003259,  80.91433048,   4.88878881],
...                 [ 51.53875334,  34.45808177,  27.5873488 ]])
>>> bytescale(img)
array([[255,   0, 236],
       [205, 225,   4],
       [140,  90,  70]], dtype=uint8)
>>> bytescale(img, high=200, low=100)
array([[200, 100, 192],
       [180, 188, 102],
       [155, 135, 128]], dtype=uint8)
>>> bytescale(img, cmin=0, cmax=255)
array([[91,  3, 84],
       [74, 81,  5],
       [52, 34, 28]], dtype=uint8)
imread(name, flatten=False, mode=None)

Read an image from a file as an array.

This function is only available if Python Imaging Library (PIL) is installed.

name : str or file object
The file name or file object to be read.
flatten : bool, optional
If True, flattens the color layers into a single gray-scale layer.
mode : str, optional
Mode to convert image to, e.g. 'RGB'. See the Notes for more details.
imread : ndarray
The array obtained by reading the image.

imread uses the Python Imaging Library (PIL) to read an image. The following notes are from the PIL documentation.

mode can be one of the following strings:

  • ‘L’ (8-bit pixels, black and white)
  • ‘P’ (8-bit pixels, mapped to any other mode using a color palette)
  • ‘RGB’ (3x8-bit pixels, true color)
  • ‘RGBA’ (4x8-bit pixels, true color with transparency mask)
  • ‘CMYK’ (4x8-bit pixels, color separation)
  • ‘YCbCr’ (3x8-bit pixels, color video format)
  • ‘I’ (32-bit signed integer pixels)
  • ‘F’ (32-bit floating point pixels)

PIL also provides limited support for a few special modes, including ‘LA’ (‘L’ with alpha), ‘RGBX’ (true color with padding) and ‘RGBa’ (true color with premultiplied alpha).

When translating a color image to black and white (mode ‘L’, ‘I’ or ‘F’), the library uses the ITU-R 601-2 luma transform:

L = R * 299/1000 + G * 587/1000 + B * 114/1000

When flatten is True, the image is converted using mode ‘F’. When mode is not None and flatten is True, the image is first converted according to mode, and the result is then flattened using mode ‘F’.

imsave(name, arr, format=None)

Save an array as an image.

This function is only available if Python Imaging Library (PIL) is installed.

Warning

This function uses bytescale under the hood to rescale images to use the full (0, 255) range if mode is one of None, 'L', 'P', 'l'. It will also cast data for 2-D images to uint32 for mode=None (which is the default).

name : str or file object
Output file name or file object.
arr : ndarray, MxN or MxNx3 or MxNx4
Array containing image values. If the shape is MxN, the array represents a grey-level image. Shape MxNx3 stores the red, green and blue bands along the last dimension. An alpha layer may be included, specified as the last colour band of an MxNx4 array.
format : str
Image format. If omitted, the format to use is determined from the file name extension. If a file object was used instead of a file name, this parameter should always be used.

Construct an array of gradient intensity values and save to file:

>>> from scipy.misc import imsave
>>> x = np.zeros((255, 255))
>>> x = np.zeros((255, 255), dtype=np.uint8)
>>> x[:] = np.arange(255)
>>> imsave('gradient.png', x)

Construct an array with three colour bands (R, G, B) and store to file:

>>> rgb = np.zeros((255, 255, 3), dtype=np.uint8)
>>> rgb[..., 0] = np.arange(255)
>>> rgb[..., 1] = 55
>>> rgb[..., 2] = 1 - np.arange(255)
>>> imsave('rgb_gradient.png', rgb)
fromimage(im, flatten=False, mode=None)

Return a copy of a PIL image as a numpy array.

This function is only available if Python Imaging Library (PIL) is installed.

im : PIL image
Input image.
flatten : bool
If true, convert the output to grey-scale.
mode : str, optional
Mode to convert image to, e.g. 'RGB'. See the Notes of the imread docstring for more details.
fromimage : ndarray
The different colour bands/channels are stored in the third dimension, such that a grey-image is MxN, an RGB-image MxNx3 and an RGBA-image MxNx4.
toimage(arr, high=255, low=0, cmin=None, cmax=None, pal=None, mode=None, channel_axis=None)

Takes a numpy array and returns a PIL image.

This function is only available if Python Imaging Library (PIL) is installed.

The mode of the PIL image depends on the array shape and the pal and mode keywords.

For 2-D arrays, if pal is a valid (N,3) byte-array giving the RGB values (from 0 to 255) then mode='P', otherwise mode='L', unless mode is given as ‘F’ or ‘I’ in which case a float and/or integer array is made.

Warning

This function uses bytescale under the hood to rescale images to use the full (0, 255) range if mode is one of None, 'L', 'P', 'l'. It will also cast data for 2-D images to uint32 for mode=None (which is the default).

For 3-D arrays, the channel_axis argument tells which dimension of the array holds the channel data.

For 3-D arrays if one of the dimensions is 3, the mode is ‘RGB’ by default or ‘YCbCr’ if selected.

The numpy array must be either 2 dimensional or 3 dimensional.

imrotate(arr, angle, interp="bilinear")

Rotate an image counter-clockwise by angle degrees.

This function is only available if Python Imaging Library (PIL) is installed.

Warning

This function uses bytescale under the hood to rescale images to use the full (0, 255) range if mode is one of None, 'L', 'P', 'l'. It will also cast data for 2-D images to uint32 for mode=None (which is the default).

arr : ndarray
Input array of image to be rotated.
angle : float
The angle of rotation.
interp : str, optional

Interpolation

  • ‘nearest’ : for nearest neighbor
  • ‘bilinear’ : for bilinear
  • ‘lanczos’ : for lanczos
  • ‘cubic’ : for bicubic
  • ‘bicubic’ : for bicubic
imrotate : ndarray
The rotated array of image.
imshow(arr)

Simple showing of an image through an external viewer.

This function is only available if Python Imaging Library (PIL) is installed.

Uses the image viewer specified by the environment variable SCIPY_PIL_IMAGE_VIEWER, or if that is not defined then see, to view a temporary file generated from array data.

Warning

This function uses bytescale under the hood to rescale images to use the full (0, 255) range if mode is one of None, 'L', 'P', 'l'. It will also cast data for 2-D images to uint32 for mode=None (which is the default).

arr : ndarray
Array of image data to show.

None

>>> a = np.tile(np.arange(255), (255,1))
>>> from scipy import misc
>>> misc.imshow(a)
imresize(arr, size, interp="bilinear", mode=None)

Resize an image.

This function is only available if Python Imaging Library (PIL) is installed.

Warning

This function uses bytescale under the hood to rescale images to use the full (0, 255) range if mode is one of None, 'L', 'P', 'l'. It will also cast data for 2-D images to uint32 for mode=None (which is the default).

arr : ndarray
The array of image to be resized.
size : int, float or tuple
  • int - Percentage of current size.
  • float - Fraction of current size.
  • tuple - Size of the output image (height, width).
interp : str, optional
Interpolation to use for re-sizing (‘nearest’, ‘lanczos’, ‘bilinear’, ‘bicubic’ or ‘cubic’).
mode : str, optional
The PIL image mode (‘P’, ‘L’, etc.) to convert arr before resizing. If mode=None (the default), 2-D images will be treated like mode='L', i.e. casting to long integer. For 3-D and 4-D arrays, mode will be set to 'RGB' and 'RGBA' respectively.
imresize : ndarray
The resized array of image.

toimage : Implicitly used to convert arr according to mode. scipy.ndimage.zoom : More generic implementation that does not use PIL.

imfilter(arr, ftype)

Simple filtering of an image.

This function is only available if Python Imaging Library (PIL) is installed.

Warning

This function uses bytescale under the hood to rescale images to use the full (0, 255) range if mode is one of None, 'L', 'P', 'l'. It will also cast data for 2-D images to uint32 for mode=None (which is the default).

arr : ndarray
The array of Image in which the filter is to be applied.
ftype : str
The filter that has to be applied. Legal values are: ‘blur’, ‘contour’, ‘detail’, ‘edge_enhance’, ‘edge_enhance_more’, ‘emboss’, ‘find_edges’, ‘smooth’, ‘smooth_more’, ‘sharpen’.
imfilter : ndarray
The array with filter applied.
ValueError
Unknown filter type. If the filter you are trying to apply is unsupported.