PIL Package

PIL Package

ArgImagePlugin Module

class PIL.ArgImagePlugin.ArgImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'ARG'

format_description = 'Animated raster graphics'

load()

seek(frame)

tell()

verify()

Verify ARG file

class PIL.ArgImagePlugin.ArgStream(fp)

Bases: PIL.PngImagePlugin.ChunkStream

Parser callbacks for ARG data

chunk_ADEF(offset, bytes)

ADEF – store image

chunk_AEND(offset, bytes)

AEND – end of animation

chunk_AFRM(offset, bytes)

AFRM – next frame follows

chunk_AHDR(offset, bytes)

AHDR – animation header

chunk_BLNK(offset, bytes)

BLNK – create blank image

chunk_DEND(offset, bytes)

chunk_DHDR(offset, bytes)

DHDR – delta image follows

chunk_IDAT(offset, bytes)

IDAT – image data block

chunk_IEND(offset, bytes)

IEND – end of image

chunk_IHDR(offset, bytes)

IHDR – full image follows

chunk_JEND(offset, bytes)

chunk_JHDR(offset, bytes)

JHDR – JPEG image follows

chunk_NAME(offset, bytes)

NAME – name the current image

chunk_PAST(offset, bytes)

PAST – paste one image into another

chunk_PLTE(offset, bytes)

PLTE – palette data

chunk_UEND(offset, bytes)

chunk_UHDR(offset, bytes)

UHDR – uncompressed image data follows (EXPERIMENTAL)

chunk_sYNC(offset, bytes)

SYNC – reset decoder

BdfFontFile Module

class PIL.BdfFontFile.BdfFontFile(fp)

Bases: PIL.FontFile.FontFile

PIL.BdfFontFile.bdf_char(f)

BmpImagePlugin Module

class PIL.BmpImagePlugin.BmpImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'BMP'

format_description = 'Windows Bitmap'

class PIL.BmpImagePlugin.DibImageFile(fp=None, filename=None)

Bases: PIL.BmpImagePlugin.BmpImageFile

format = 'DIB'

format_description = 'Windows Bitmap'

BufrStubImagePlugin Module

class PIL.BufrStubImagePlugin.BufrStubImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.StubImageFile

format = 'BUFR'

format_description = 'BUFR'

PIL.BufrStubImagePlugin.register_handler(handler)

ContainerIO Module

class PIL.ContainerIO.ContainerIO(file, offset, length)

isatty()

read(n=0)

readline()

readlines()

seek(offset, mode=0)

tell()

CurImagePlugin Module

class PIL.CurImagePlugin.CurImageFile(fp=None, filename=None)

Bases: PIL.BmpImagePlugin.BmpImageFile

format = 'CUR'

format_description = 'Windows Cursor'

DcxImagePlugin Module

class PIL.DcxImagePlugin.DcxImageFile(fp=None, filename=None)

Bases: PIL.PcxImagePlugin.PcxImageFile

format = 'DCX'

format_description = 'Intel DCX'

seek(frame)

tell()

EpsImagePlugin Module

class PIL.EpsImagePlugin.EpsImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

EPS File Parser for the Python Imaging Library

format = 'EPS'

format_description = 'Encapsulated Postscript'

load()

PIL.EpsImagePlugin.Ghostscript(tile, size, fp)

Render an image using Ghostscript

class PIL.EpsImagePlugin.PSFile(fp)

Wrapper that treats either CR or LF as end of line.

read(count)

readline()

seek(offset, whence=0)

tell()

ExifTags Module

FitsStubImagePlugin Module

class PIL.FitsStubImagePlugin.FITSStubImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.StubImageFile

format = 'FITS'

format_description = 'FITS'

PIL.FitsStubImagePlugin.register_handler(handler)

FliImagePlugin Module

class PIL.FliImagePlugin.FliImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'FLI'

format_description = 'Autodesk FLI/FLC Animation'

seek(frame)

tell()

FontFile Module

class PIL.FontFile.FontFile

bitmap = None

compile()

Create metrics and bitmap

save(filename)

Save font in version 1 format

save1(filename)

Save font in version 1 format

save2(filename)

Save font in version 2 format

PIL.FontFile.puti16(fp, values)

FpxImagePlugin Module

class PIL.FpxImagePlugin.FpxImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'FPX'

format_description = 'FlashPix'

load()

GbrImagePlugin Module

class PIL.GbrImagePlugin.GbrImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'GBR'

format_description = 'GIMP brush file'

load()

GdImageFile Module

class PIL.GdImageFile.GdImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'GD'

format_description = 'GD uncompressed images'

PIL.GdImageFile.open(fp, mode='r')

GifImagePlugin Module

class PIL.GifImagePlugin.GifImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

data()

format = 'GIF'

format_description = 'Compuserve GIF'

global_palette = None

seek(frame)

tell()

PIL.GifImagePlugin.getdata(im, offset=(0, 0), **params)

Return a list of strings representing this image. The first string is a local image header, the rest contains encoded image data.

PIL.GifImagePlugin.getheader(im, palette=None, info=None)

Return a list of strings representing a GIF header

GimpGradientFile Module

class PIL.GimpGradientFile.GimpGradientFile(fp)

Bases: PIL.GimpGradientFile.GradientFile

class PIL.GimpGradientFile.GradientFile

getpalette(entries=256)

gradient = None

PIL.GimpGradientFile.curved(middle, pos)

PIL.GimpGradientFile.linear(middle, pos)

PIL.GimpGradientFile.sine(middle, pos)

PIL.GimpGradientFile.sphere_decreasing(middle, pos)

PIL.GimpGradientFile.sphere_increasing(middle, pos)

GimpPaletteFile Module

class PIL.GimpPaletteFile.GimpPaletteFile(fp)

getpalette()

rawmode = 'RGB'

GribStubImagePlugin Module

class PIL.GribStubImagePlugin.GribStubImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.StubImageFile

format = 'GRIB'

format_description = 'GRIB'

PIL.GribStubImagePlugin.register_handler(handler)

Hdf5StubImagePlugin Module

class PIL.Hdf5StubImagePlugin.HDF5StubImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.StubImageFile

format = 'HDF5'

format_description = 'HDF5'

PIL.Hdf5StubImagePlugin.register_handler(handler)

IcnsImagePlugin Module

class PIL.IcnsImagePlugin.IcnsFile(fobj)

SIZES = {(16, 16): [('is32', <function read_32 at 0xf60fe374>), ('s8mk', <function read_mk at 0xf60fe3ac>)], (48, 48): [('ih32', <function read_32 at 0xf60fe374>), ('h8mk', <function read_mk at 0xf60fe3ac>)], (128, 128): [('it32', <function read_32t at 0xf60fe33c>), ('t8mk', <function read_mk at 0xf60fe3ac>)], (32, 32): [('il32', <function read_32 at 0xf60fe374>), ('l8mk', <function read_mk at 0xf60fe3ac>)]}

bestsize()

dataforsize(size)

Get an icon resource as {channel: array}. Note that the arrays are bottom-up like windows bitmaps and will likely need to be flipped or transposed in some way.

getimage(size=None)

itersizes()

class PIL.IcnsImagePlugin.IcnsImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

PIL read-only image support for Mac OS .icns files. Chooses the best resolution, but will possibly load a different size image if you mutate the size attribute before calling ‘load’.

The info dictionary has a key ‘sizes’ that is a list of sizes that the icns file has.

format = 'ICNS'

format_description = 'Mac OS icns resource'

load()

PIL.IcnsImagePlugin.nextheader(fobj)

PIL.IcnsImagePlugin.read_32(fobj, start_length, size)

Read a 32bit RGB icon resource. Seems to be either uncompressed or an RLE packbits-like scheme.

PIL.IcnsImagePlugin.read_32t(fobj, start_length, size)

PIL.IcnsImagePlugin.read_mk(fobj, start_length, size)

IcoImagePlugin Module

class PIL.IcoImagePlugin.IcoImageFile(fp=None, filename=None)

Bases: PIL.BmpImagePlugin.BmpImageFile

format = 'ICO'

format_description = 'Windows Icon'

ImImagePlugin Module

class PIL.ImImagePlugin.ImImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'IM'

format_description = 'IFUNC Image Memory'

seek(frame)

tell()

PIL.ImImagePlugin.number(s)

Image Module

class PIL.Image.Image

convert(mode=None, data=None, dither=None, palette=0, colors=256)

Convert to other pixel format

copy()

Copy raster data

crop(box=None)

Crop region from image

draft(mode, size)

Configure image decoder

filter(filter)

Apply environment filter to image

format = None

format_description = None

frombytes(data, decoder_name='raw', *args)

Load data to image from a bytes object

fromstring(*args, **kw)

Deprecated alias to frombytes

getbands()

Get band names

getbbox()

Get bounding box of actual data (non-zero pixels) in image

getcolors(maxcolors=256)

Get colors from image, up to given limit

getdata(band=None)

Get image data as sequence object.

getextrema()

Get min/max value

getim()

Get capsule pointer to internal image memory

getpalette()

Get palette contents.

getpixel(xy)

Get pixel value

getprojection()

Get projection to x and y axes

histogram(mask=None, extrema=None)

Take histogram of image

load()

Explicitly load pixel data.

offset(xoffset, yoffset=None)

(deprecated) Offset image in horizontal and/or vertical direction

paste(im, box=None, mask=None)

Paste other image into region

point(lut, mode=None)

Map image through lookup table

putalpha(alpha)

Set alpha layer

putdata(data, scale=1.0, offset=0.0)

Put data from a sequence object into an image.

putpalette(data, rawmode='RGB')

Put palette data into an image.

putpixel(xy, value)

Set pixel value

quantize(colors=256, method=0, kmeans=0, palette=None)

resize(size, resample=0)

Resize image

rotate(angle, resample=0, expand=0)

Rotate image. Angle given as degrees counter-clockwise.

save(fp, format=None, **params)

Save image to file or stream

seek(frame)

Seek to given frame in sequence file

show(title=None, command=None)

Display image (for debug purposes only)

split()

Split image into bands

tell()

Return current frame number

thumbnail(size, resample=0)

Create thumbnail representation (modifies image in place)

tobitmap(name='image')

Return image as an XBM bitmap

tobytes(encoder_name='raw', *args)

Return image as a bytes object

tostring(*args, **kw)

transform(size, method, data=None, resample=0, fill=1)

Transform image

transpose(method)

Transpose image (flip or rotate in 90 degree steps)

verify()

Verify file contents.

class PIL.Image.ImagePointHandler

class PIL.Image.ImageTransformHandler

PIL.Image.alpha_composite(im1, im2)

Alpha composite im2 over im1.

PIL.Image.blend(im1, im2, alpha)

Interpolate between images.

PIL.Image.coerce_e(value)

PIL.Image.composite(image1, image2, mask)

Create composite image by blending images using a transparency mask

PIL.Image.eval(image, *args)

Evaluate image expression

PIL.Image.fromarray(obj, mode=None)

PIL.Image.frombuffer(mode, size, data, decoder_name='raw', *args)

Load image from bytes or buffer

PIL.Image.frombytes(mode, size, data, decoder_name='raw', *args)

Load image from byte buffer

PIL.Image.fromstring(*args, **kw)

Deprecated alias to frombytes

PIL.Image.getmodebandnames(mode)

PIL.Image.getmodebands(mode)

PIL.Image.getmodebase(mode)

PIL.Image.getmodetype(mode)

PIL.Image.init()

Load all file format drivers.

PIL.Image.isDirectory(f)

PIL.Image.isImageType(t)

PIL.Image.isStringType(t)

PIL.Image.merge(mode, bands)

Merge a set of single band images into a new multiband image.

PIL.Image.new(mode, size, color=0)

Create a new image

PIL.Image.open(fp, mode='r')

Open an image file, without loading the raster data

PIL.Image.preinit()

Load standard file format drivers.

PIL.Image.register_extension(id, extension)

PIL.Image.register_mime(id, mimetype)

PIL.Image.register_open(id, factory, accept=None)

PIL.Image.register_save(id, driver)

ImageChops Module

PIL.ImageChops.add(image1, image2, scale=1.0, offset=0)

Add two images

PIL.ImageChops.add_modulo(image1, image2)

Add two images without clipping

PIL.ImageChops.blend(image1, image2, alpha)

Blend two images using a constant transparency weight

PIL.ImageChops.composite(image1, image2, mask)

Create composite image by blending images using a transparency mask

PIL.ImageChops.constant(image, value)

Fill a channel with a given grey level

PIL.ImageChops.darker(image1, image2)

Select the darker pixels from each image

PIL.ImageChops.difference(image1, image2)

Subtract one image from another

PIL.ImageChops.duplicate(image)

Create a copy of a channel

PIL.ImageChops.invert(image)

Invert a channel

PIL.ImageChops.lighter(image1, image2)

Select the lighter pixels from each image

PIL.ImageChops.logical_and(image1, image2)

Logical and between two images

PIL.ImageChops.logical_or(image1, image2)

Logical or between two images

PIL.ImageChops.logical_xor(image1, image2)

Logical xor between two images

PIL.ImageChops.multiply(image1, image2)

Superimpose two positive images

PIL.ImageChops.offset(image, xoffset, yoffset=None)

Offset image in horizontal and/or vertical direction

PIL.ImageChops.screen(image1, image2)

Superimpose two negative images

PIL.ImageChops.subtract(image1, image2, scale=1.0, offset=0)

Subtract two images

PIL.ImageChops.subtract_modulo(image1, image2)

Subtract two images without clipping

ImageCms Module

ImageColor Module

PIL.ImageColor.getcolor(color, mode)

PIL.ImageColor.getrgb(color)

ImageDraw Module

PIL.ImageDraw.Draw(im, mode=None)

class PIL.ImageDraw.ImageDraw(im, mode=None)

arc(xy, start, end, fill=None)

bitmap(xy, bitmap, fill=None)

chord(xy, start, end, fill=None, outline=None)

ellipse(xy, fill=None, outline=None)

getfont()

line(xy, fill=None, width=0)

pieslice(xy, start, end, fill=None, outline=None)

point(xy, fill=None)

polygon(xy, fill=None, outline=None)

rectangle(xy, fill=None, outline=None)

setfill(onoff)

setfont(font)

setink(ink)

shape(shape, fill=None, outline=None)

text(xy, text, fill=None, font=None, anchor=None)

textsize(text, font=None)

PIL.ImageDraw.floodfill(image, xy, value, border=None)

Fill bounded region.

PIL.ImageDraw.getdraw(im=None, hints=None)

ImageDraw2 Module

class PIL.ImageDraw2.Brush(color, opacity=255)

class PIL.ImageDraw2.Draw(image, size=None, color=None)

arc(xy, start, end, *options)

chord(xy, start, end, *options)

ellipse(xy, *options)

flush()

line(xy, *options)

pieslice(xy, start, end, *options)

polygon(xy, *options)

rectangle(xy, *options)

render(op, xy, pen, brush=None)

settransform(offset)

symbol(xy, symbol, *options)

text(xy, text, font)

textsize(text, font)

class PIL.ImageDraw2.Font(color, file, size=12)

class PIL.ImageDraw2.Pen(color, width=1, opacity=255)

ImageEnhance Module

class PIL.ImageEnhance.Brightness(image)

Bases: PIL.ImageEnhance._Enhance

Adjust image brightness

class PIL.ImageEnhance.Color(image)

Bases: PIL.ImageEnhance._Enhance

Adjust image colour balance

class PIL.ImageEnhance.Contrast(image)

Bases: PIL.ImageEnhance._Enhance

Adjust image contrast

class PIL.ImageEnhance.Sharpness(image)

Bases: PIL.ImageEnhance._Enhance

Adjust image sharpness

ImageFile Module

class PIL.ImageFile.ImageFile(fp=None, filename=None)

Bases: PIL.Image.Image

Base class for image file format handlers.

draft(mode, size)

Set draft mode

load()

Load image data based on tile list

load_end()

load_prepare()

verify()

Check file integrity

class PIL.ImageFile.Parser

close()

data = None

decoder = None

feed(data)

finished = 0

image = None

incremental = None

reset()

class PIL.ImageFile.StubImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

Base class for stub image loaders.

load()

PIL.ImageFile.raise_ioerror(error)

ImageFileIO Module

class PIL.ImageFileIO.ImageFileIO(fp)

Bases: _io.BytesIO

ImageFilter Module

class PIL.ImageFilter.BLUR

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((5, 5), 16, 0, (1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1))

name = 'Blur'

class PIL.ImageFilter.BuiltinFilter

Bases: PIL.ImageFilter.Kernel

class PIL.ImageFilter.CONTOUR

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 1, 255, (-1, -1, -1, -1, 8, -1, -1, -1, -1))

name = 'Contour'

class PIL.ImageFilter.DETAIL

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 6, 0, (0, -1, 0, -1, 10, -1, 0, -1, 0))

name = 'Detail'

class PIL.ImageFilter.EDGE_ENHANCE

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 2, 0, (-1, -1, -1, -1, 10, -1, -1, -1, -1))

name = 'Edge-enhance'

class PIL.ImageFilter.EDGE_ENHANCE_MORE

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 1, 0, (-1, -1, -1, -1, 9, -1, -1, -1, -1))

name = 'Edge-enhance More'

class PIL.ImageFilter.EMBOSS

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 1, 128, (-1, 0, 0, 0, 1, 0, 0, 0, 0))

name = 'Emboss'

class PIL.ImageFilter.FIND_EDGES

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 1, 0, (-1, -1, -1, -1, 8, -1, -1, -1, -1))

name = 'Find Edges'

class PIL.ImageFilter.Filter

Bases: object

class PIL.ImageFilter.GaussianBlur(radius=2)

Bases: PIL.ImageFilter.Filter

filter(image)

name = 'GaussianBlur'

class PIL.ImageFilter.Kernel(size, kernel, scale=None, offset=0)

Bases: PIL.ImageFilter.Filter

filter(image)

class PIL.ImageFilter.MaxFilter(size=3)

Bases: PIL.ImageFilter.RankFilter

name = 'Max'

class PIL.ImageFilter.MedianFilter(size=3)

Bases: PIL.ImageFilter.RankFilter

name = 'Median'

class PIL.ImageFilter.MinFilter(size=3)

Bases: PIL.ImageFilter.RankFilter

name = 'Min'

class PIL.ImageFilter.ModeFilter(size=3)

Bases: PIL.ImageFilter.Filter

filter(image)

name = 'Mode'

class PIL.ImageFilter.RankFilter(size, rank)

Bases: PIL.ImageFilter.Filter

filter(image)

name = 'Rank'

class PIL.ImageFilter.SHARPEN

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 16, 0, (-2, -2, -2, -2, 32, -2, -2, -2, -2))

name = 'Sharpen'

class PIL.ImageFilter.SMOOTH

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((3, 3), 13, 0, (1, 1, 1, 1, 5, 1, 1, 1, 1))

name = 'Smooth'

class PIL.ImageFilter.SMOOTH_MORE

Bases: PIL.ImageFilter.BuiltinFilter

filterargs = ((5, 5), 100, 0, (1, 1, 1, 1, 1, 1, 5, 5, 5, 1, 1, 5, 44, 5, 1, 1, 5, 5, 5, 1, 1, 1, 1, 1, 1))

name = 'Smooth More'

class PIL.ImageFilter.UnsharpMask(radius=2, percent=150, threshold=3)

Bases: PIL.ImageFilter.Filter

filter(image)

name = 'UnsharpMask'

ImageFont Module

class PIL.ImageFont.FreeTypeFont(file, size, index=0, encoding='')

FreeType font wrapper (requires _imagingft service)

getmask(text, mode='')

getmask2(text, mode='', fill=<built-in function fill>)

getmetrics()

getname()

getsize(text)

class PIL.ImageFont.ImageFont

PIL font wrapper

class PIL.ImageFont.TransposedFont(font, orientation=None)

Wrapper for writing rotated or mirrored text

getmask(text, mode='')

getsize(text)

PIL.ImageFont.load(filename)

Load a font file.

PIL.ImageFont.load_default()

Load a default font.

PIL.ImageFont.load_path(filename)

Load a font file, searching along the Python path.

PIL.ImageFont.truetype(filename, size, index=0, encoding='')

Load a truetype font file.

ImageMath Module

PIL.ImageMath.eval(expression, _dict={}, **kw)

PIL.ImageMath.imagemath_convert(self, mode)

PIL.ImageMath.imagemath_equal(self, other)

PIL.ImageMath.imagemath_float(self)

PIL.ImageMath.imagemath_int(self)

PIL.ImageMath.imagemath_max(self, other)

PIL.ImageMath.imagemath_min(self, other)

PIL.ImageMath.imagemath_notequal(self, other)

PIL.ImageMath.v(self, other)

ImageMode Module

class PIL.ImageMode.ModeDescriptor(mode, bands, basemode, basetype)

PIL.ImageMode.getmode(mode)

ImageOps Module

PIL.ImageOps.autocontrast(image, cutoff=0, ignore=None)

Maximize image contrast, based on histogram

PIL.ImageOps.colorize(image, black, white)

Colorize a grayscale image

PIL.ImageOps.crop(image, border=0)

Crop border off image

PIL.ImageOps.deform(image, deformer, resample=2)

Deform image using the given deformer

PIL.ImageOps.equalize(image, mask=None)

Equalize image histogram

PIL.ImageOps.expand(image, border=0, fill=0)

Add border to image

PIL.ImageOps.fit(image, size, method=0, bleed=0.0, centering=(0.5, 0.5))

This method returns a sized and cropped version of the image, cropped to the aspect ratio and size that you request.

PIL.ImageOps.flip(image)

Flip image vertically

PIL.ImageOps.gaussian_blur(im, radius=None)

PIL_usm.gblur(im, [radius])

PIL.ImageOps.gblur(im[, radius])

PIL.ImageOps.grayscale(image)

Convert to grayscale

PIL.ImageOps.invert(image)

Invert image (negate)

PIL.ImageOps.mirror(image)

Flip image horizontally

PIL.ImageOps.posterize(image, bits)

Reduce the number of bits per color channel

PIL.ImageOps.solarize(image, threshold=128)

Invert all values above threshold

PIL.ImageOps.unsharp_mask(im, radius=None, percent=None, threshold=None)

PIL_usm.usm(im, [radius, percent, threshold])

PIL.ImageOps.usm(im[, radius, percent, threshold])

ImagePalette Module

class PIL.ImagePalette.ImagePalette(mode='RGB', palette=None)

Colour palette for palette mapped images

getcolor(color)

getdata()

save(fp)

tobytes()

tostring()

PIL.ImagePalette.load(filename)

PIL.ImagePalette.negative(mode='RGB')

PIL.ImagePalette.new(mode, data)

PIL.ImagePalette.random(mode='RGB')

PIL.ImagePalette.raw(rawmode, data)

PIL.ImagePalette.sepia(white='#fff0c0')

PIL.ImagePalette.wedge(mode='RGB')

ImagePath Module

ImageQt Module

class PIL.ImageQt.ImageQt(im)

Bases: PyQt4.QtGui.QImage

PIL.ImageQt.rgb(r, g, b)

ImageSequence Module

class PIL.ImageSequence.Iterator(im)

ImageShow Module

class PIL.ImageShow.DisplayViewer

Bases: PIL.ImageShow.UnixViewer

get_command_ex(file, **options)

class PIL.ImageShow.UnixViewer

Bases: PIL.ImageShow.Viewer

show_file(file, **options)

class PIL.ImageShow.Viewer

format = None

get_command(file, **options)

get_format(image)

save_image(image)

show(image, **options)

show_file(file, **options)

show_image(image, **options)

class PIL.ImageShow.XVViewer

Bases: PIL.ImageShow.UnixViewer

get_command_ex(file, title=None, **options)

PIL.ImageShow.register(viewer, order=1)

PIL.ImageShow.show(image, title=None, **options)

PIL.ImageShow.which(executable)

ImageStat Module

PIL.ImageStat.Global

alias of Stat

class PIL.ImageStat.Stat(image_or_list, mask=None)

Get image or feature statistics

ImageTk Module

class PIL.ImageTk.BitmapImage(image=None, **kw)

height()

width()

class PIL.ImageTk.PhotoImage(image=None, size=None, **kw)

height()

paste(im, box=None)

width()

PIL.ImageTk.getimage(photo)

ImageTransform Module

class PIL.ImageTransform.AffineTransform(data)

Bases: PIL.ImageTransform.Transform

method = 0

class PIL.ImageTransform.ExtentTransform(data)

Bases: PIL.ImageTransform.Transform

method = 1

class PIL.ImageTransform.MeshTransform(data)

Bases: PIL.ImageTransform.Transform

method = 4

class PIL.ImageTransform.QuadTransform(data)

Bases: PIL.ImageTransform.Transform

method = 3

class PIL.ImageTransform.Transform(data)

Bases: PIL.Image.ImageTransformHandler

getdata()

transform(size, image, **options)

ImageWin Module

class PIL.ImageWin.Dib(image, size=None)

draw(handle, dst, src=None)

expose(handle)

frombytes(buffer)

fromstring(*args, **kw)

paste(im, box=None)

query_palette(handle)

tobytes()

tostring()

class PIL.ImageWin.HDC(dc)

class PIL.ImageWin.HWND(wnd)

class PIL.ImageWin.ImageWindow(image, title='PIL')

Bases: PIL.ImageWin.Window

ui_handle_repair(dc, x0, y0, x1, y1)

class PIL.ImageWin.Window(title='PIL', width=None, height=None)

mainloop()

ui_handle_clear(dc, x0, y0, x1, y1)

ui_handle_damage(x0, y0, x1, y1)

ui_handle_destroy()

ui_handle_repair(dc, x0, y0, x1, y1)

ui_handle_resize(width, height)

ImtImagePlugin Module

class PIL.ImtImagePlugin.ImtImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'IMT'

format_description = 'IM Tools'

IptcImagePlugin Module

class PIL.IptcImagePlugin.IptcImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

field()

format = 'IPTC'

format_description = 'IPTC/NAA'

getint(key)

load()

PIL.IptcImagePlugin.dump(c)

PIL.IptcImagePlugin.getiptcinfo(im)

PIL.IptcImagePlugin.i(c)

JpegImagePlugin Module

PIL.JpegImagePlugin.APP(self, marker)

PIL.JpegImagePlugin.COM(self, marker)

PIL.JpegImagePlugin.DQT(self, marker)

class PIL.JpegImagePlugin.JpegImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

draft(mode, size)

format = 'JPEG'

format_description = 'JPEG (ISO 10918)'

load_djpeg()

PIL.JpegImagePlugin.SOF(self, marker)

PIL.JpegImagePlugin.Skip(self, marker)

PIL.JpegImagePlugin.convert_dict_qtables(qtables)

PIL.JpegImagePlugin.get_sampling(im)

JpegPresets Module

JPEG quality settings equivalent to the Photoshop settings.

More presets can be added to the presets dict if needed.

Can be use when saving JPEG file.

To apply the preset, specify:

quality="preset_name"

To apply only the quantization table:

qtables="preset_name"

To apply only the subsampling setting:

subsampling="preset_name"

Example:

im.save("image_name.jpg", quality="web_high")

Subsampling

Subsampling is the practice of encoding images by implementing less resolution for chroma information than for luma information. (ref.: http://en.wikipedia.org/wiki/Chroma_subsampling)

Possible subsampling values are 0, 1 and 2 that correspond to 4:4:4, 4:2:2 and 4:1:1 (or 4:2:0?).

You can get the subsampling of a JPEG with the JpegImagePlugin.get_subsampling(im) function.

Quantization tables

They are values use by the DCT (Discrete cosine transform) to remove unnecessary information from the image (the lossy part of the compression). (ref.: http://en.wikipedia.org/wiki/Quantization_matrix#Quantization_matrices, http://en.wikipedia.org/wiki/JPEG#Quantization)

You can get the quantization tables of a JPEG with:

im.quantization

This will return a dict with a number of arrays. You can pass this dict directly as the qtables argument when saving a JPEG.

The tables format between im.quantization and quantization in presets differ in 3 ways:

1. The base container of the preset is a list with sublists instead of dict. dict[0] -> list[0], dict[1] -> list[1], ...
2. Each table in a preset is a list instead of an array.
3. The zigzag order is remove in the preset (needed by libjpeg >= 6a).

You can convert the dict format to the preset format with the JpegImagePlugin.convert_dict_qtables(dict_qtables) function.

Libjpeg ref.: http://www.jpegcameras.com/libjpeg/libjpeg-3.html

McIdasImagePlugin Module

class PIL.McIdasImagePlugin.McIdasImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'MCIDAS'

format_description = 'McIdas area file'

MicImagePlugin Module

class PIL.MicImagePlugin.MicImageFile(fp=None, filename=None)

Bases: PIL.TiffImagePlugin.TiffImageFile

format = 'MIC'

format_description = 'Microsoft Image Composer'

seek(frame)

tell()

MpegImagePlugin Module

class PIL.MpegImagePlugin.BitStream(fp)

next()

peek(bits)

read(bits)

skip(bits)

class PIL.MpegImagePlugin.MpegImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'MPEG'

format_description = 'MPEG'

MspImagePlugin Module

class PIL.MspImagePlugin.MspImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'MSP'

format_description = 'Windows Paint'

OleFileIO Module

class PIL.OleFileIO.OleFileIO(filename=None)

OLE container object

This class encapsulates the interface to an OLE 2 structured storage file. Use the listdir and openstream methods to access the contents of this file.

Object names are given as a list of strings, one for each subentry level. The root entry should be omitted. For example, the following code extracts all image streams from a Microsoft Image Composer file:

ole = OleFileIO("fan.mic")

for entry in ole.listdir():
    if entry[1:2] == "Image":
        fin = ole.openstream(entry)
        fout = open(entry[0:1], "wb")
        while 1:
            s = fin.read(8192)
            if not s:
                break
            fout.write(s)

You can use the viewer application provided with the Python Imaging Library to view the resulting files (which happens to be standard TIFF files).

dumpdirectory()

getproperties(filename)

Return properties described in substream

getsect(sect)

listdir()

Return a list of streams stored in this file

loaddirectory(sect)

loadfat(header)

loadminifat()

open(filename)

Open an OLE2 file

openstream(filename)

Open a stream as a read-only file object

PSDraw Module

class PIL.PSDraw.PSDraw(fp=None)

begin_document(id=None)

Write Postscript DSC header

end_document()

Write Postscript DSC footer

image(box, im, dpi=None)

Write an PIL image

line(xy0, xy1)

rectangle(box)

setfont(font, size)

setink(ink)

text(xy, text)

PaletteFile Module

class PIL.PaletteFile.PaletteFile(fp)

getpalette()

rawmode = 'RGB'

PalmImagePlugin Module

PIL.PalmImagePlugin.build_prototype_image()

PcdImagePlugin Module

class PIL.PcdImagePlugin.PcdImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

draft(mode, size)

format = 'PCD'

format_description = 'Kodak PhotoCD'

PcfFontFile Module

class PIL.PcfFontFile.PcfFontFile(fp)

Bases: PIL.FontFile.FontFile

name = 'name'

PIL.PcfFontFile.sz(s, o)

PcxImagePlugin Module

class PIL.PcxImagePlugin.PcxImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'PCX'

format_description = 'Paintbrush'

PdfImagePlugin Module

PixarImagePlugin Module

class PIL.PixarImagePlugin.PixarImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'PIXAR'

format_description = 'PIXAR raster image'

PngImagePlugin Module

class PIL.PngImagePlugin.ChunkStream(fp)

call(cid, pos, len)

Call the appropriate chunk handler

close()

crc(cid, data)

Read and verify checksum

crc_skip(cid, data)

Read checksum. Used if the C module is not present

push(cid, pos, len)

read()

Fetch a new chunk. Returns header information.

verify(endchunk='IEND')

class PIL.PngImagePlugin.PngImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'PNG'

format_description = 'Portable network graphics'

load_end()

internal: finished reading image data

load_prepare()

internal: prepare to read PNG file

load_read(bytes)

internal: read more image data

verify()

Verify PNG file

class PIL.PngImagePlugin.PngInfo

add(cid, data)

add_text(key, value, zip=0)

class PIL.PngImagePlugin.PngStream(fp)

Bases: PIL.PngImagePlugin.ChunkStream

chunk_IDAT(pos, len)

chunk_IEND(pos, len)

chunk_IHDR(pos, len)

chunk_PLTE(pos, len)

chunk_gAMA(pos, len)

chunk_iCCP(pos, len)

chunk_pHYs(pos, len)

chunk_tEXt(pos, len)

chunk_tRNS(pos, len)

chunk_zTXt(pos, len)

PIL.PngImagePlugin.getchunks(im, **params)

Return a list of PNG chunks representing this image.

PIL.PngImagePlugin.is_cid()

match(string[, pos[, endpos]]) –> match object or None. Matches zero or more characters at the beginning of the string

PIL.PngImagePlugin.putchunk(fp, cid, *data)

Write a PNG chunk (including CRC field)

PpmImagePlugin Module

class PIL.PpmImagePlugin.PpmImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'PPM'

format_description = 'Pbmplus image'

PsdImagePlugin Module

class PIL.PsdImagePlugin.PsdImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'PSD'

format_description = 'Adobe Photoshop'

load_prepare()

seek(layer)

tell()

SgiImagePlugin Module

class PIL.SgiImagePlugin.SgiImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'SGI'

format_description = 'SGI Image File Format'

SpiderImagePlugin Module

class PIL.SpiderImagePlugin.SpiderImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

convert2byte(depth=255)

format = 'SPIDER'

format_description = 'Spider 2D image'

seek(frame)

tell()

tkPhotoImage()

PIL.SpiderImagePlugin.isInt(f)

PIL.SpiderImagePlugin.isSpiderHeader(t)

PIL.SpiderImagePlugin.isSpiderImage(filename)

PIL.SpiderImagePlugin.loadImageSeries(filelist=None)

create a list of Image.images for use in montage

PIL.SpiderImagePlugin.makeSpiderHeader(im)

SunImagePlugin Module

class PIL.SunImagePlugin.SunImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'SUN'

format_description = 'Sun Raster File'

TarIO Module

class PIL.TarIO.TarIO(tarfile, file)

Bases: PIL.ContainerIO.ContainerIO

TgaImagePlugin Module

class PIL.TgaImagePlugin.TgaImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'TGA'

format_description = 'Targa'

TiffImagePlugin Module

class PIL.TiffImagePlugin.ImageFileDirectory(prefix)

Bases: _abcoll.MutableMapping

as_dict()

Return a dictionary of the image’s tags.

getscalar(tag, default=None)

has_key(tag)

items()

load(fp)

load_byte(data)

load_dispatch = {1: (1, <function load_byte at 0xf298fdbc>), 2: (1, <function load_string at 0xf298fdf4>), 3: (2, <function load_short at 0xf298fe2c>), 4: (4, <function load_long at 0xf298fe64>), 5: (8, <function load_rational at 0xf298fe9c>), 7: (1, <function load_undefined at 0xf298ff44>), 11: (4, <function load_float at 0xf298fed4>), 12: (8, <function load_double at 0xf298ff0c>)}

load_double(data)

load_float(data)

load_long(data)

load_rational(data)

load_short(data)

load_string(data)

load_undefined(data)

named()

Returns the complete tag dictionary, with named tags where posible.

reset()

save(fp)

class PIL.TiffImagePlugin.TiffImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'TIFF'

format_description = 'Adobe TIFF'

seek(frame)

Select a given frame as current image

tell()

Return the current frame number

TiffTags Module

WalImageFile Module

PIL.WalImageFile.open(filename)

WebPImagePlugin Module

class PIL.WebPImagePlugin.WebPImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'WEBP'

format_description = 'WebP image'

WmfImagePlugin Module

class PIL.WmfImagePlugin.WmfStubImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.StubImageFile

format = 'WMF'

format_description = 'Windows Metafile'

PIL.WmfImagePlugin.register_handler(handler)

PIL.WmfImagePlugin.short(c, o=0)

XVThumbImagePlugin Module

class PIL.XVThumbImagePlugin.XVThumbImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'XVThumb'

format_description = 'XV thumbnail image'

XbmImagePlugin Module

class PIL.XbmImagePlugin.XbmImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'XBM'

format_description = 'X11 Bitmap'

XpmImagePlugin Module

class PIL.XpmImagePlugin.XpmImageFile(fp=None, filename=None)

Bases: PIL.ImageFile.ImageFile

format = 'XPM'

format_description = 'X11 Pixel Map'

load_read(bytes)

_binary Module

PIL._binary.i16be(c, o=0)

PIL._binary.i16le(c, o=0)

PIL._binary.i32be(c, o=0)

PIL._binary.i32le(c, o=0)

PIL._binary.i8(c)

PIL._binary.o16be(i)

PIL._binary.o16le(i)

PIL._binary.o32be(i)

PIL._binary.o32le(i)

PIL._binary.o8(i)