PIL库里的基本知识概念

首先，介绍一下PIL中的基本概念。

PIL中所涉及的基本概念有如下几个：通道（bands）、模式（mode）、尺寸（size）、坐标系统（coordinate system）、调色板（palette）、信息（info）和滤波器（filters）。

1、通道

每张图片都是由一个或者多个数据通道构成。PIL允许在单张图片中合成相同维数和深度的多个通道。

以RGB图像为例，每张图片都是由三个数据通道构成，分别为R、G和B通道。而对于灰度图像，则只有一个通道。

对于一张图片的通道数量和名称，可以通过方法getbands()来获取。方法getbands()是Image模块的方法，它会返回一个字符串元组（tuple）。该元组将包括每一个通道的名称。

Python的元组与列表类似，不同之处在于元组的元素不能修改,元组使用小括号，列表使用方括号，元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

方法getbands()的使用如下：

>>>from PIL import Image
>>>im= Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.getbands()
('R', 'G', 'B')

>>>im_bands = im.getbands()
>>>len(im_bands)
3

>>>print im_bands[0]
R

>>>print im_bands[1]
G

>>>print im_bands[2]
B

2、模式

图像的模式定义了图像的类型和像素的位宽。当前支持如下模式：

1：1位像素，表示黑和白，但是存储的时候每个像素存储为8bit。

L：8位像素，表示黑和白。

P：8位像素，使用调色板映射到其他模式。

RGB：3x8位像素，为真彩色。

RGBA：4x8位像素，有透明通道的真彩色。

CMYK：4x8位像素，颜色分离。

YCbCr：3x8位像素，彩色视频格式。

I：32位整型像素。

F：32位浮点型像素。

PIL也支持一些特殊的模式，包括RGBX（有padding的真彩色）和RGBa（有自左乘alpha的真彩色）。

可以通过mode属性读取图像的模式。其返回值是包括上述模式的字符串。

属性mode的使用如下：

>>>from PIL importImage
>>>im =Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.mode
'RGB'

>>>md = im.mode
>>>print md
RGB

3、尺寸

通过size属性可以获取图片的尺寸。这是一个二元组，包含水平和垂直方向上的像素数。

属性mode的使用如下：

>>>from PIL importImage
>>>im =Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.size
(800, 450)

>>>im_size = im.size
>>>print im_size[0]
800

>>>print im_size[1]
450

4、坐标系统

PIL使用笛卡尔像素坐标系统，坐标(0，0)位于左上角。注意：坐标值表示像素的角；位于坐标（0，0）处的像素的中心实际上位于（0.5，0.5）。

坐标经常用于二元组（x，y）。长方形则表示为四元组，前面是左上角坐标。例如，一个覆盖800x600的像素图像的长方形表示为（0，0，800，600）。

5、调色板

调色板模式 (“P”)使用一个颜色调色板为每个像素定义具体的颜色值

6、信息

使用info属性可以为一张图片添加一些辅助信息。这个是字典对象。加载和保存图像文件时，多少信息需要处理取决于文件格式。

属性info的使用如下：

>>>from PIL import Image
>>>im =Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.info
{'jfif_version':(1, 1), 'jfif': 257, 'jfif_unit': 1, 'jfif_density': (96, 96), 'dpi': (96, 96)}

>>>im_info = im.info
>>>im_info
{'jfif_version':(1, 1), 'jfif': 257, 'jfif_unit': 1, 'jfif_density': (96, 96), 'dpi': (96, 96)}

>>>print im_info['jfif_version']
(1, 1)

>>>print im_info['jfif']
257

7、滤波器

对于将多个输入像素映射为一个输出像素的几何操作，PIL提供了4个不同的采样滤波器：

NEAREST：最近滤波。从输入图像中选取最近的像素作为输出像素。它忽略了所有其他的像素。

BILINEAR：双线性滤波。在输入图像的2x2矩阵上进行线性插值。注意：PIL的当前版本，做下采样时该滤波器使用了固定输入模板。

BICUBIC：双立方滤波。在输入图像的4x4矩阵上进行立方插值。注意：PIL的当前版本，做下采样时该滤波器使用了固定输入模板。

ANTIALIAS：平滑滤波。这是PIL 1.1.3版本中新的滤波器。对所有可以影响输出像素的输入像素进行高质量的重采样滤波，以计算输出像素值。在当前的PIL版本中，这个滤波器只用于改变尺寸和缩略图方法。

注意：在当前的PIL版本中，ANTIALIAS滤波器是下采样（例如，将一个大的图像转换为小图）时唯一正确的滤波器。BILIEAR和BICUBIC滤波器使用固定的输入模板，用于固定比例的几何变换和上采样是最好的。

Image模块中的方法resize()和thumbnail()用到了滤波器。

方法resize()的使用如下：

方法resize()的定义为：resize(size, filter=None)=> image

>>>from PIL import Image
>>>im= Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.size
(800, 450)

>>>im_resize = im.resize((256,256))
>>>im_resize.size
(256, 256)

对参数filter不赋值的话，方法resize()默认使用NEAREST滤波器。如果要使用其他滤波器可以通过下面的方法来实现：

>>>im_resize0 = im.resize((256,256), Image.BILINEAR)
>>>im_resize0.size
(256, 256)

>>>im_resize1 = im.resize((256,256), Image.BICUBIC)
>>>im_resize1.size
(256, 256)

>>>im_resize2 = im.resize((256,256), Image.ANTIALIAS)
>>>im_resize2.size
(256, 256)

方法thumbnail ()的使用如下：

方法thumbnail ()的定义为：im.thumbnail(size, filter=None)

>>>from PIL import Image
>>>im= Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.size
(800, 450)

>>>im.thumbnail((200,200))
>>>im.size
(200,112)

这里需要说明的是，方法thumbnail()需要保持宽高比，对于size=(200,200)的输入参数，其最终的缩略图尺寸为(200, 112)。

对参数filter不赋值的话，方法thumbnail()默认使用NEAREST滤波器。如果要使用其他滤波器可以通过下面的方法来实现：

>>>im= Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.size
(800, 450)

>>>im.thumbnail((200,200),Image.BILINEAR)
>>>im.size
(200, 112)

>>>im= Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.size
(800, 450)

>>>im.thumbnail((200,200), Image.BICUBIC)
>>>im.size
(200, 112)

>>>im= Image.open('D:\\Code\\Python\\test\\img\\1.jpg')
>>>im.size
(800, 450)

>>>im.thumbnail((200,200), Image.ANTIALIAS)
>>>im.size
(200, 112)

接着，说说PIL中的Image模块

Image模块是PIL中最重要的模块，它有一个类叫做image，与模块名称相同。Image类有很多函数、方法及属性，接下来将依次对image类的属性、函数和方法进行介绍。

一、Image类的属性

1、 Format

定义：im.format ⇒ string or None

含义：源文件的文件格式。如果是由PIL创建的图像，则其文件格式为None。

例子：

>>>from PIL import Image
>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.jpg")
>>>im.format
'JPEG'
注：test.jpg是JPEG图像，所以其文件格式为JPEG。

>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.gif")
>>>im.format
'GIF'
注：test.gif为GIF文件，所以其文件格式为GIF。

2、 Mode

定义：im.mode ⇒ string

含义：图像的模式。这个字符串表明图像所使用像素格式。该属性典型的取值为“1”，“L”，“RGB”或“CMYK”。

例子：

>>>from PIL import Image
>>>im = Image.open("D:\\Code\\Python\\test\\img\\test.jpg")
>>>im.mode
'RGB'

>>>im = Image.open("D:\\Code\\Python\\test\\img\\test.gif")
>>>im.mode
'P'

3、 Size

定义：im.size ⇒ (width, height)

含义：图像的尺寸，按照像素数计算。它的返回值为宽度和高度的二元组（width, height）。

例子：

>>>from PIL import Image
>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.jpg")
>>>im.size
(800, 450)

>>> im= Image.open("D:\\Code\\Python\\test\\img\\test.gif")
>>> im.size
(400, 220)

4、 Palette

定义：im.palette ⇒ palette or None

含义：颜色调色板表格。如果图像的模式是“P”，则返回ImagePalette类的实例；否则，将为None。

例子：

>>>from PIL import Image
>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.jpg")
>>>im.mode
'RGB'

>>>im.palette

>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.gif")
>>>im.mode
'P'

>>>im.palette
<PIL.ImagePalette.ImagePaletteobject at 0x035E7AD0>

>>>pl= im.palette
Pl为ImagePalette类的实例。

5、 Info

定义：im.info ⇒ dictionary

含义：存储图像相关数据的字典。文件句柄使用该字典传递从文件中读取的各种非图像信息。大多数方法在返回新的图像时都会忽略这个字典；因为字典中的键并非标准化的，对于一个方法，它不能知道自己的操作如何影响这个字典。如果用户需要这些信息，需要在方法open()返回时保存这个字典。

例子：

>>>from PIL import Image
>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.jpg")
>>>im.info
{'jfif_version':(1, 1), 'jfif': 257, 'jfif_unit': 1, 'jfif_density': (96, 96), 'dpi': (96, 96)}

>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.gif")
>>>im.info
{'duration':100, 'version': 'GIF89a', 'extension': ('NETSCAPE2.0', 795L), 'background': 0,'loop': 0}

二、Image类的函数

1、 New

定义：Image.new(mode,size) ⇒ image

Image.new(mode, size, color) ⇒ image

含义：使用给定的变量mode和size生成新的图像。Size是给定的宽/高二元组，这是按照像素数来计算的。对于单通道图像，变量color只给定一个值；对于多通道图像，变量color给定一个元组（每个通道对应一个值）。在版本1.1.4及其之后，用户也可以用颜色的名称，比如给变量color赋值为“red”。如果没有对变量color赋值，图像内容将会被全部赋值为0（图像即为黑色）。如果变量color是空，图像将不会被初始化，即图像的内容全为0。这对向该图像复制或绘制某些内容是有用的。

例子：

>>>from PIL import Image
>>>im= Image.new("RGB", (128, 128), "#FF0000")
>>>im.show()
图像im为128x128大小的红色图像。

>>>im= Image.new("RGB", (128, 128))
>>>im.show()
图像im为128x128大小的黑色图像，因为变量color不赋值的话，图像内容被设置为0，即黑色。

>>>im= Image.new("RGB", (128, 128), "red")
>>>im.show
图像im为128x128大小的红色图像。

2、 Open

定义：Image.open(file) ⇒ image

Image.open(file, mode) ⇒ image

含义：打开并确认给定的图像文件。这个是一个懒操作；该函数只会读文件头，而真实的图像数据直到试图处理该数据才会从文件读取（调用load()方法将强行加载图像数据）。如果变量mode被设置，那必须是“r”。

用户可以使用一个字符串（表示文件名称的字符串）或者文件对象作为变量file的值。文件对象必须实现read()，seek()和tell()方法，并且以二进制模式打开。

例子：

>>>from PIL import Image
>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.jpg")
>>>im.show()

>>>im= Image.open("D:\\Code\\Python\\test\\img\\test.jpg", "r")
>>>im.show()

open-show

3、 Blend

定义：Image.blend(image1,image2, alpha) ⇒ image

含义：使用给定的两张图像及透明度变量alpha，插值出一张新的图像。这两张图像必须有一样的尺寸和模式。

合成公式为：out = image1 (1.0 - alpha) + image2 alpha

如果变量alpha为0.0，将返回第一张图像的拷贝。如果变量alpha为1.0，将返回第二张图像的拷贝。对变量alpha的值没有限制。

例子：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>im02 =Image.open("D:\\Code\\Python\\test\\img\\test02.jpg")
>>>im =Image.blend(im01, im02, 0.3)
>>>im.show()

Test01.jpg和test02.jpg两张图像size都为1024x768，mode为“RGB”。它们按照第一张70%的透明度，第二张30%的透明度，合成为一张。

4、 Composite

定义：Image.composite(image1,image2, mask) ⇒ image

含义：使用给定的两张图像及mask图像作为透明度，插值出一张新的图像。变量mask图像的模式可以为“1”，“L”或者“RGBA”。所有图像必须有相同的尺寸。

例子：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>im02 =Image.open("D:\\Code\\Python\\test\\img\\test02.jpg")

>>>r,g,b = im01.split()
>>>g.mode
'L'

>>> g.size
(1024, 768)

>>>im= Image.composite(im01, im02, g)
>>>im.show()

5、 Eval

定义：Image.eval(image,function) ⇒ image

含义：使用变量function对应的函数（该函数应该有一个参数）处理变量image所代表图像中的每一个像素点。如果变量image所代表图像有多个通道，那变量function对应的函数作用于每一个通道。注意：变量function对每个像素只处理一次，所以不能使用随机组件和其他生成器。

例子：

>>>from PIL import Image
>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>def fun(x):
         return x * 0.5
>>>im_eval = Image.eval(im01, fun)
>>>im_eval.show()
>>>im01.show()

图像im01如下图：

图像im_eval如下图：

图像im_eval与im01比较，其像素值均为im01的一半，则其亮度自然也会比im01暗一些。

6、 Frombuffer

定义：Image.frombuffer(mode,size, data) ⇒ image

Image.frombuffer(mode, size,data, decoder, parameters) ⇒ image

含义：（New in PIL 1.1.4）使用标准的“raw”解码器，从字符串或者buffer对象中的像素数据产生一个图像存储。对于一些模式，这个图像存储与原始的buffer（这意味着对原始buffer对象的改变体现在图像本身）共享内存。并非所有的模式都可以共享内存；支持的模式有“L”，“RGBX”，“RGBA”和“CMYK”。对于其他模式，这个函数与fromstring()函数一致。

注意：版本1.1.6及其以下，这个函数的默认情况与函数fromstring()不同。这有可能在将来的版本中改变，所以为了最大的可移植性，当使用“raw”解码器时，推荐用户写出所有的参数，如下所示：

1
2
3

im=Image.frombuffer(mode, size, data, "raw", mode, 0, 1)

函数Image.frombuffer(mode,size, data, decoder, parameters)与函数fromstring()的调用一致。

7、 Fromstring

定义：Image.fromstring(mode,size, data) ⇒ image

Image.fromstring(mode, size,data, decoder, parameters) ⇒ image

含义：函数Image.fromstring(mode,size, data)，使用标准的“raw”解码器，从字符串中的像素数据产生一个图像存储。

函数Image.fromstring(mode,size, data, decoder, parameters)也一样，但是允许用户使用PIL支持的任何像素解码器。更多信息可以参考：Writing YourOwn File Decoder.

注意：这个函数只对像素数据进行解码，而不是整个图像。如果用户的字符串包含整个图像，可以将该字符串包裹在StringIO对象中，使用函数open()来加载。

8、 Merge

定义：Image.merge(mode,bands) ⇒ image

含义：使用一些单通道图像，创建一个新的图像。变量bands为一个图像的元组或者列表，每个通道的模式由变量mode描述。所有通道必须有相同的尺寸。

变量mode与变量bands的关系：

len(ImageMode.getmode(mode).bands)= len(bands)

例子：

>>>from PIL import Image
>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>im02 = Image.open("D:\\Code\\Python\\test\\img\\test02.jpg")
>>>r1,g1,b1 = im01.split()
>>>r2,g2,b2 = im02.split()
>>>r1.mode
'L'

>>>r1.size
(1024, 768)

>>>g1.mode
'L'

>>>g1.size
(1024, 768)

>>>r2.mode
'L'

>>>g2.size
(1024, 768)

>>>imgs=[r1,g2,b2]

>>>len(ImageMode.getmode("RGB").bands)
3

>>>len(imgs)
3

>>>im_merge = Image.merge("RGB", imgs)
>>>im_merge.show()

三、Image类的方法

除非另作说明，Image类的所有方法都将返回一个Image类的新实例，这个实例对应于结果图像。

1、 Convert

定义1：im.convert(mode)⇒ image

含义1：将当前图像转换为其他模式，并且返回新的图像。

当从一个调色板图像转换时，这个方法通过这个调色板来转换像素。如果不对变量mode赋值，该方法将会选择一种模式，在没有调色板的情况下，使得图像和调色板中的所有信息都可以被表示出来。

当从一个颜色图像转换为黑白图像时，PIL库使用ITU-R601-2 luma转换公式：

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

当转换为2位图像（模式“1”）时，源图像首先被转换为黑白图像。结果数据中大于127的值被设置为白色，其他的设置为黑色；这样图像会出现抖动。如果要使用其他阈值，更改阈值127，可以使用方法point()。为了去掉图像抖动现象，可以使用dither选项。

例子1：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.mode

'RGB'

>>>im_c = im01.convert("L")

>>>im_c.mode

'L'

将“RGB”模式的im01图像，转换为“L”模式的im_c图像。

定义2：im.convert(“P”,**options) ⇒ image

含义2：这个与第一个方法定义一样，但是当“RGB”图像转换为8位调色板图像时能更好的处理。可供选择的选项为：

Dither=. 控制颜色抖动。默认是FLOYDSTEINBERG，与邻近的像素一起承担错误。不使能该功能，则赋值为NONE。

Palette=. 控制调色板的产生。默认是WEB，这是标准的216色的“web palette”。要使用优化的调色板，则赋值为ADAPTIVE。

Colors=. 当选项palette为ADAPTIVE时，控制用于调色板的颜色数目。默认是最大值，即256种颜色。

例子2：

 

定义3：im.convert(mode,matrix) ⇒ image

含义3：使用转换矩阵将一个“RGB”图像转换为“L”或者“RGB”图像。变量matrix为4或者16元组。

例子3：下面的例子将一个RGB图像（根据ITU-R709线性校准，使用D65亮度）转换到CIE XYZ颜色空间：

>>>from PIL import Image

>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.mode

'RGB'

>>>rgb2xyz = (

             0.412453,0.357580, 0.180423, 0,

                       0.212671,0.715160, 0.072169, 0,

                       0.019334,0.119193, 0.950227, 0 )

 

>>>im_c3 = im01.convert("L", rgb2xyz)

>>>im_c3.show()

>>>im_c3.mode

'L'

2、 Copy

定义：im.copy() ⇒ image

含义：拷贝这个图像。如果用户想粘贴一些数据到这张图，可以使用这个方法，但是原始图像不会受到影响。

例子：

1
2
3

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>im_copy = im01.copy()

图像im_copy和im01完全一样。

3、 Crop

定义：im.crop(box) ⇒ image

含义：从当前的图像中返回一个矩形区域的拷贝。变量box是一个四元组，定义了左、上、右和下的像素坐标。

这是一个懒操作。对源图像的改变可能或者可能不体现在裁减下来的图像中。为了获取一个分离的拷贝，对裁剪的拷贝调用方法load()。

例子：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>box= [0, 0, 100, 100]
>>>im_crop = im01.crop(box)
>>>im_crop.mode
'RGB'

>>>im_crop.size
(100, 100)

4、 Draft

定义：im.draft(mode,size)

含义：配置图像文件加载器，使得返回一个与给定的模式和尺寸尽可能匹配的图像的版本。例如，用户可以使用这个方法，在加载一个彩色JPEG图像时将其转换为灰色图像，或者从一个PCD文件中提取一个128x192的版本。

注意：这个方法会适时地修改图像对象（精确地说，它会重新配置文件的读取器）。如果图像已经被加载，那这个方法就没有作用了。

例子：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>im01.size
(1024, 768)

>>>im01.mode
'RGB'

>>>im01.draft("L", (100,100))
<PIL.JpegImagePlugin.JpegImageFileimage mode=L size=128x96 at 0x3B69230>

>>>im01.size
(128, 96)
>>>im01.mode
'L'

5、 Filter

定义：im.filter(filter) ⇒ image

含义：返回一个使用给定滤波器处理过的图像的拷贝。可用滤波器需要参考ImageFilter模块。

例子：

>>>from PIL import Image

>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im_filter = im01.filter(ImageFilter.BLUR)

>>>im_filter.show()

图像im_filter比im01变得有些模糊了。

6、 Fromstring

定义：im.fromstring(data)

im.fromstring(data, decoder,parameters)

含义：与函数fromstring()一样，但是这个方法会将data加载到当前的图像中。

7、 Getbands

定义：im.getbands()⇒ tuple of strings

含义：返回包括每个通道名称的元组。例如，对于RGB图像将返回（“R”，“G”，“B”）。

例子：

>>>from PIL import Image

>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.getbands()

('R', 'G', 'B')

8、 Getbbox

定义：im.getbbox() ⇒ 4-tuple or None

含义：计算图像非零区域的包围盒。这个包围盒是一个4元组，定义了左、上、右和下像素坐标。如果图像是空的，这个方法将返回空。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.getbbox()

(0, 0, 1024,768)

9、 Getcolors

定义：im.getcolors() ⇒ a list of(count, color) tuples or None

im.getcolors(maxcolors) ⇒ a list of (count, color) tuples or None

含义：（New in 1.1.5）返回一个（count，color）元组的无序list，其中count是对应颜色在图像中出现的次数。

如果变量maxcolors的值被超过，该方法将停止计算并返回空。变量maxcolors默认值为256。为了保证用户可以获取图像中的所有颜色，you can pass in size[0]*size[1]（请确保有足够的内存做这件事）。

例子：

>>>from PIL import Image

>>>im01= Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.getcolors()

>>>im01.getcolors(256)

>>>ls= im01.getcolors(255)

>>>len(ls)

 

Traceback (mostrecent call last):

  File "<pyshell#201>", line 1,in <module>

    len(ls)

TypeError:object of type 'NoneType' has no len()

 

不知道为什么图像im01.getcolors()返回为空，这个后续需要进一步研究。

10、 Getdata

定义：im.getdata() ⇒ sequence

含义：以包含像素值的sequence对象形式返回图像的内容。这个sequence对象是扁平的，以便第一行的值直接跟在第零行的值后面，等等。

注意：这个方法返回的sequence对象是PIL内部数据类型，它只支持某些sequence操作，包括迭代和基础sequence访问。使用list(im.getdata())，将它转换为普通的sequence。

例子：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>seq= im01.getdata()
>>>seq0 = list(seq)
>>>seq[0]
(11, 113, 198)

>>>seq[2]
(9, 111, 196)

>>>seq0[0]
(11, 113, 198)

>>>seq0[2]
(9, 111, 196)

Sequence对象的每一个元素对应一个像素点的R、G和B三个值。

11、Getextrema

定义：im.getextrema() ⇒ 2-tuple

含义：返回一个2元组，包括该图像中的最小和最大值。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.getextrema()

((0, 255), (0,255), (0, 255))

该方法返回了R/G/B三个通道的最小和最大值的2元组。

12、Getpixel

定义：im.getpixel(xy) ⇒ value or tuple

含义：返回给定位置的像素值。如果图像为多通道，则返回一个元组。

注意：该方法执行比较慢；如果用户需要使用python处理图像中较大部分数据，可以使用像素访问对象（见load），或者方法getdata()。

例子：

>>>from PIL import Image

>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.getpixel((0,0))

(11, 113, 198)

>>>im01.getpixel((1,1))

(10, 112, 197)

>>>r,g,b = im01.split()

>>>r.getpixel((0,0))

11

13、Histogram

定义1：im.histogram()⇒ list

含义1：返回一个图像的直方图。这个直方图是关于像素数量的list，图像中的每个像素值对应一个成员。如果图像有多个通道，所有通道的直方图会连接起来（例如，“RGB”图像的直方图有768个值）。

二值图像（模式为“1”）当作灰度图像（模式为“L”）处理。

例子1：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>ls= im01.histogram()
>>>len(ls)
768

>>>ls[0]
359

>>>ls[256]
295

>>>ls[767]
109953

图像im01为RGB图像，所以有768项。

定义2：im.histogram(mask)⇒ list

含义2：返回图像中模板图像非零地方的直方图。模板图像与处理图像的尺寸必须相同，并且要么是二值图像（模式为“1”），要么为灰度图像（模式为“L”）。

例子2：

>>>from PIL import Image
>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>>>r,g,b = im01.split()
>>>r.mode
'L'

>>>ls= im01.histogram(r)
>>>len(ls)
768

>>>ls[0]
0

>>>ls[256]
248

>>>ls[767]
109953

14、Load

定义：im.load()

含义：为图像分配内存并从文件中加载它（或者从源图像，对于懒操作）。正常情况下，用户不需要调用这个方法，因为在第一次访问图像时，Image类会自动地加载打开的图像。

（New in 1.1.6）在1.1.6及以后的版本，方法load()返回一个用于读取和修改像素的像素访问对象。这个访问对象像一个二维队列，如：

pix = im.load()

print pix[x, y]

pix[x, y] =value

通过这个对象访问比方法getpixel()和putpixel()快很多。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>pix= im01.load()

>>>pix[0,0]

(11, 113, 198)

15、Offset

定义：im.offset(xoffset,yoffset) ⇒ image

含义：（不赞成）返回按照给定位置的偏移对应的图像的拷贝。数据延续到图像的边缘。如果变量yoffset没有赋值，将假设其与变量xoffset一样。

不赞成使用这个方法，在PIL 1.2版本中去掉该方法。新的代码将使用ImageChops模块中的offset()函数。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>img= im01.offset(1,1)

 

Traceback (mostrecent call last):

  File "<pyshell#38>", line 1,in <module>

    img = im01.offset(1,1)

  File"C:\Python27\lib\site-packages\PIL\Image.py", line 1246, in offset

    "Please call ImageChops.offset()instead.")

Exception:offset() has been removed. Please call ImageChops.offset() instead.

由此可见，该版本中已经去掉了方法offset()。

16、 Paste

定义1：im.paste(image,box)

含义1：将一张图粘贴到另一张图像上。变量box或者是一个给定左上角的2元组，或者是定义了左，上，右和下像素坐标的4元组，或者为空（与（0，0）一样）。如果给定4元组，被粘贴的图像的尺寸必须与区域尺寸一样。

如果模式不匹配，被粘贴的图像将被转换为当前图像的模式。

例子1：

>>>from PIL import Image

>>>im01= Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>box=[0,0,100,100]

>>>im_crop = im01.crop(box)

>>>im_crop.size

(100, 100)

>>>im_crop.mode

'RGB'

>>>im01.paste(im_crop, (200,200))

>>>im01.paste(im_crop, (500,500,600,600))

>>>im01.show()

我们先从图像im01中裁剪出一个100x100的图像，它的模式与im01一样都是“RGB”。然后通过2元组和4元组的方式，将裁剪出来的图像粘贴到图像im01上。在图像im01的（200，200）和（500，500）两个位置分别出现了裁剪出来的100x100的图像。其结果如下图所示：

定义2：im.paste(colour,box)

含义2：它与定义1一样，但是它使用同一种颜色填充变量box对应的区域。对于单通道图像，变量colour为单个颜色值；对于多通道，则为一个元组。

例子2：

>>>from PIL import Image

>>>im01= Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

 

>>>im01.paste((0,256,0),(0,0,100,100))

图像im01的（0，0）位置将出现一个100x100的绿色方块。

 

>>>im01.paste(255,(0,0,100,100))

图像im01的（0，0）位置将出现一个100x100的红色方块。对于多通道的图像，如果变量colour只给定一个数值，将只会应用于图像的第一个通道。如果是“RGB”模式的图像，将应用于红色通道。

定义3：im.paste(image,box, mask)

含义3：与定义1一样，但是它使用变量mask对应的模板图像来填充所对应的区域。可以使用模式为“1”、“L”或者“RGBA”的图像作为模板图像。模板图像的尺寸必须与变量image对应的图像尺寸一致。如果变量mask对应图像的值为255，则模板图像的值直接被拷贝过来；如果变量mask对应图像的值为0，则保持当前图像的原始值。变量mask对应图像的其他值，将对两张图像的值进行透明融合。

注意：如果变量image对应的为“RGBA”图像，即粘贴的图像模式为“RGBA”，则alpha通道被忽略。用户可以使用同样的图像作为原图像和模板图像。

例子3：

>>>from PIL import Image

>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>box =[500,500,600,600]

>>>im_crop =im01.crop(box)

>>>r,g,b =im_crop.split()

>>>im01.paste(im_crop, (0,0,100,100), r)

>>>im01.show()

在图像im01的（0，0）位置将出现一个半透明的100x100的方块。

定义4：im.paste(colour,box, mask)

含义4：与定义3一样，只是使用变量colour对应的单色来填充区域。

例子4：

>>>from PIL import Image

>>>im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

 

>>>box= [500,500,600,600]

>>>im_crop = im01.crop(box)

>>>r,g,b = im_crop.split()

>>>im01.paste((0,256,0), (0,0,100,100), r)

>>>im01.show()

在图像im01的（0，0）位置将出现一个100x100的绿色方块。

17、 Point

定义1：im.point(table)⇒ image

im.point(function) ⇒ image

含义1：返回给定查找表对应的图像像素值的拷贝。变量table为图像的每个通道设置256个值。如果使用变量function，其对应函数应该有一个参数。这个函数将对每个像素值使用一次，结果表格将应用于图像的所有通道。

如果图像的模式为“I（整数）”或者“F（浮点）”，用户必须使用function方式，function必须按照下面的格式：

argument * scale+ offset

例如：

out = im.point(lambda i: i * 1.2 + 10)

用户可以省略变量scale和offset。

例子1：

>>>from PIL import Image

>>> im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im_point_fun = im01.point(lambda i:i*1.2+10)

>>>im_point_fun.show()

图像im_point_fun比原图im01亮度增加了很多；因为lambda表达式中对原图的每个像素点的值都做了增加操作。

Lambda表达式是python中可以替代简单函数的一种方式，它只能封装有限的逻辑，但是对于某些情况，使用起来还是很方便的。

定义lambda函数的形式如下：labmda参数：表达式lambda函数默认返回表达式的值。你也可以将其赋值给一个变量。lambda函数可以接受任意个参数，包括可选参数，但是表达式只有一个。

Lambda表达式的例子：

>>>range(10)

[0, 1, 2, 3, 4,5, 6, 7, 8, 9]

如果我们要对这10个数字，逐个做加一操作，可以使用如下表达式：

>>>map(lambda x:x+1, [y for y in range(10)])

[1, 2, 3, 4, 5,6, 7, 8, 9, 10]

函数map()是python的内置函数，其格式如下：

map( func,seq1[, seq2...]

Python函数式编程中的map()函数是将func作用于seq中的每一个元素，并用一个列表给出返回值。如果func为None，作用同zip()。

当seq只有一个时，将func函数作用于这个seq的每个元素上，得到一个新的seq。

例如：

>>>map(lambda x:x+10, range(10))

[10, 11, 12, 13,14, 15, 16, 17, 18, 19]

当seq多于一个时，map可以并行地对每个seq执行。每个seq的同一位置的元素在执行过一个多元的func函数之后，得到一个返回值，这些返回值放在一个结果列表中。需要注意的是，不同长度的多个seq是无法执行map函数的，会出现类型错误。

例如：

>>>map(lambda x,y:x+y, [1,2,3],[4,5,6])

[5, 7, 9]

func是None的情况，它的目的是将多个列表相同位置的元素归并到一个元组，在现在已经有了专用的函数zip()了。

例如：

>>>map(None, [1,2,3],[4,5,6])

[(1, 4), (2, 5),(3, 6)]

>>>zip([1,2,3],[4,5,6])

[(1, 4), (2, 5),(3, 6)]

zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。利用*号操作符，可以将list unzip（解压）。

例如：

>>> a =[1,2,3]

>>> b =[2,3,4]

>>> b =[4,5,6]

>>> c =[4,5,6,7,8]

>>>zipped = zip(a,b)

>>>zipped

[(1, 4), (2, 5),(3, 6)]

>>>zip(a,c)

[(1, 4), (2, 5),(3, 6)]

>>>zip(*zipped)

[(1, 2, 3), (4,5, 6)]

定义2：im.point(table,mode) ⇒ image

im.point(function, mode) ⇒ image

含义2：与定义1一样，但是它会为输出图像指定一个新的模式。这个方法可以一步将模式为“L”和“P”的图像转换为模式为“1”的图像。

（New in 1.1.5）这个方法也可以将“L”图像转换为“I”和“F”模式，或者将16 位的“I”模式图像转换为“L”模式，此时必须使用65536项的查找表。

例子2：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>r,g,b = im01.split()

>>>r.mode

'L'

>>> im= r.point(lambda x:x*1.3+5, "1")

>>>im.show()

>>>im.getpixel((0,0))

19

图像im为全白图；

>>> im= r.point(lambda x:1, "1")

>>>im.show()

>>>im.getpixel((0,0))

1

图像im为全白图；

>>>im= r.point(lambda x:x*0, "1")

>>>im.show()

>>>im.getpixel((0,0))

0

图像im为全黑图；

18、 Putalpha

定义：im.putalpha(band)

含义：将给定的通道拷贝到图像的alpha层。此处的图像模式必须为“RGBA”，变量band必须为“L”或者“1”。

（New in PIL 1.1.5）方法putalpha()也可以用于其他模式；图像原地转换为有alpha通道的模式（通常转换为“LA”或者“RGBA”）。变量band要么为图像，要么为颜色值（一个整数）。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.mode

'RGB'

>>>im01.putalpha(100)

>>>im01.mode

'RGBA'

>>>im01.getpixel((0,0))

(11, 113, 198,100)

19、 Putdata

定义：im.putdata(data)

im.putdata(data, scale, offset)

含义：从sequence对象中拷贝数据到当前图像，从图像的左上角（0，0）位置开始。变量scale和offset用来调整sequence中的值：

pixel = value *scale + offset

如果变量scale忽略，则默认为1.0。如果变量offset忽略，则默认为0.0。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> r,g,b =im01.split()

>>>r.getpixel((0,0))

11

>>>r.getpixel((1,0))

10

>>>r.getpixel((2,0))

9

>>>r.getpixel((3,0))

6

>>>r.putdata([1,2,3,4])

>>>r.getpixel((0,0))

1

>>>r.getpixel((1,0))

2

>>>r.getpixel((2,0))

3

>>>r.getpixel((3,0))

4

20、 Putpalette

定义：im.putpalette(sequence)

含义：为“P”或者“L”图像增加一个调色板。对于“L”图像，它的模式将变化为“P”。调色板序列需要包含768项整数，每组三个值表示对应像素的红，绿和蓝。用户可以使用768个byte的字符串代替这个整数序列。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>r,g,b = im01.split()

>>>r.mode

'L'

>>>r.putpalette([1,2,3])

>>> r.mode

'P'

21、 Putpixel

定义：im.putpixel(xy,colour)

含义：修改指定位置上的像素值。对于单通道图像，变量colour为一个数值；对于多通道图像，变量colour为一个元组。

注意：这个方法执行比较慢。如果是1.1.6版本，像素访问对象（参考load方法）提供了一个更快的方法修改图像。如果用户要生成整幅图像，可以使用更有效的方法产生一个python list，然后使用方法putdata()将它拷贝到图像上去。对于更大的改变，使用方法paste或者ImageDraw模块。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.getpixel((0,0))

(11, 113, 198)

>>>im01.putpixel((0,0),(1,2,3))

>>>im01.getpixel((0,0))

(1, 2, 3)

22、 Quantize

定义：im.quantize(colors,**options) ⇒ image

含义：（不赞成）使用给定的颜色将“L”或者“RGB”图像转换为“P”图像，返回新的图像。

新的代码中，使用有自适应的调色板的convert方法来代替：

out =im.convert(“P”, palette=Image.ADAPTIVE,colors=256)

23、 Resize

定义：im.resize(size) ⇒ image

im.resize(size, filter) ⇒ image

含义：返回改变尺寸的图像的拷贝。变量size是所要求的尺寸，是一个二元组：（width, height）。

变量filter为NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果忽略，或者图像模式为“1”或者“P”，该变量设置为NEAREST。

注意：在当前的版本中bilinear和bicubic滤波器不能很好地适应大比例的下采样（例如生成缩略图）。用户需要使用ANTIALIAS，除非速度比质量更重要。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.size

(1024, 768)

>>> im= im01.resize((512, 384))

>>>im.size

(512, 384)

24、 Rotate

定义：im.rotate(angle) ⇒ image

im.rotate(angle,filter=NEAREST, expand=0) ⇒ image

含义：返回一个按照给定角度顺时钟围绕图像中心旋转后的图像拷贝。

变量filter应该是NEAREST、BILINEAR或者BICUBIC之一。如果省略该变量，或者图像模式为“1”或者“P”，则默认为NEAREST。

变量expand，如果为true，表示输出图像足够大，可以装载旋转后的图像。如果为false或者缺省，则输出图像与输入图像尺寸一样大。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> im01.size

(1024, 768)

>>>im_30 = im01.rotate(30)

>>>im_30.size

(1024, 768)

>>>im_30_1 = im01.rotate(30, Image.BICUBIC,1)

>>>im_30_1.size

(1271, 1178)

25、Save

定义：im.save(outfile,options…)

im.save(outfile, format, options…)

含义：使用给定的文件名保存图像。如果变量format缺省，如果可能的话，则从文件名称的扩展名判断文件的格式。该方法返回为空。

关键字options为文件编写器提供一些额外的指令。如果编写器不能识别某个选项，它将忽略它。

用户可以使用文件对象代替文件名称。在这种情况下，用户必须指定文件格式。文件对象必须实现了seek()、tell()和write()方法，且其以二进制模式打开。

如果方法save()因为某些原因失败，这个方法将产生一个异常（通常为IOError异常）。如果发生了异常，该方法也有可能已经创建了文件，并向文件写入了一些数据。如果需要的话，用户的应用程序可以删除这个不完整的文件。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")
>
>>>im01.size

(1024, 768)

>>>im_30 = im01.rotate(30)

>>>im_30.save("D:\\Code\\Python\\test\\img\\test_rotate_30.jpg")

26、 Seek

定义：im.seek(frame)

含义：在给定的文件序列中查找指定的帧。如果查找超越了序列的末尾，则产生一个EOFError异常。当文件序列被打开时，PIL库自动指定到第0帧上。

注意：在当前的版本上，大多数序列格式只允许用户查找下一帧，不能跳跃式查找指定的帧。

例子：

>>>from PIL import Image

>>>im_gif = Image.open("D:\\Code\\Python\\test\\img\\test.gif")

>>>im_gif.mode

'P'

>>>im_gif.show()

>>>im_gif.seek(2)

>>>im_gif.show()

>>>im_gif.seek(8)

>>>im_gif.show()

通过上面的code，分别找到了第2帧和第8帧图像。

27、 Show

定义：im.show()

含义：显示一张图像。这个方法主要用于调试。

在Unix平台，这个方法将图像保存为临时的PPM文件，并且调用xv功能。

在widows中，它将图像保存为临时的BMP文件，并且使用标准的BMP显示功能显示它。

这个方法返回空。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> im01.show()

28、 Split

定义：im.split() ⇒ sequence

含义：返回当前图像各个通道组成的一个元组。例如，分离一个“RGB”图像将产生三个新的图像，分别对应原始图像的每个通道（红，绿，蓝）。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>r,g,b = im01.split()

>>>r.mode

'L'

>>>r.size

(1024, 768)

>>>im01.mode

'RGB'

>>>im01.size

(1024, 768)

29、 Tell

定义：im.tell() ⇒ integer

含义：返回当前帧所处位置，从0开始计算。

例子：

>>>from PIL import Image

>>>im_gif = Image.open("D:\\Code\\Python\\test\\img\\test.gif")

>>>im_gif.tell()

0

>>>im_gif.seek(8)

>>>im_gif.tell()

8

30、 Thumbnail

定义：im.thumbnail(size)

im.thumbnail(size, filter)

含义：修改当前图像，使其包含一个自身的缩略图，该缩略图尺寸不大于给定的尺寸。这个方法会计算一个合适的缩略图尺寸，使其符合当前图像的宽高比，调用方法draft()配置文件读取器，最后改变图像的尺寸。

变量filter应该是NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果省略该变量，则默认为NEAREST。

注意：在当前PIL的版本中，滤波器bilinear和bicubic不能很好地适应缩略图产生。用户应该使用ANTIALIAS，图像质量最好。如果处理速度比图像质量更重要，可以选用其他滤波器。

这个方法在原图上进行修改。如果用户不想修改原图，可以使用方法copy()拷贝一个图像。这个方法返回空。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.thumbnail((100,100))

应该已经为图像im01创建了不大于100x100的缩略图。

31、 Tobitmap

定义：im.tobitmap()⇒ string

含义：返回转换为X11的bitmap图像。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>str0 = im01.tobitmap()

 

Traceback (mostrecent call last):

  File "<pyshell#279>", line 1,in <module>

    str0 = im01.tobitmap()

  File"C:\Python27\lib\site-packages\PIL\Image.py", line 710, in tobitmap

    raise ValueError("not a bitmap")

ValueError: nota bitmap

暂时不知道因为什么原因，需要debug。

32、 Tostring

定义：im.tostring() ⇒ string

含义：返回一个使用标准“raw”编码器生成的包含像素数据的字符串。

例子：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>str0 = im01.tostring()

Traceback (mostrecent call last):

  File "<pyshell#281>", line 1,in <module>

    str0= im01.tostring()

  File"C:\Python27\lib\site-packages\PIL\Image.py", line 695, in tostring

    "Please call tobytes() instead.")

Exception:tostring() has been removed. Please call tobytes() instead.

当前PIL版本已经去除了该方法。

33、 Transform

定义1：im.transform(size,method, data) ⇒ image

im.transform(size, method, data, filter) ⇒ image

含义1：使用给定的尺寸生成一张新的图像，与原图有相同的模式，使用给定的转换方式将原图数据拷贝到新的图像中。

在当前的PIL版本中，参数method为EXTENT（裁剪出一个矩形区域），AFFINE（仿射变换），QUAD（将正方形转换为矩形），MESH（一个操作映射多个正方形）或者PERSPECTIVE。

变量filter定义了对原始图像中像素的滤波器。在当前的版本中，变量filter为NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果忽略，或者图像模式为“1”或者“P”，该变量设置为NEAREST。

例子1：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> im01.size

(1024, 768)

>>> trans1 =im01.transform((300,300), Image.EXTENT, (0, 0, 600, 600))

>>> trans1.size

(300, 300)

定义2：im.transform(size,EXTENT, data) ⇒ image

im.transform(size, EXTENT, data, filter) ⇒ image

含义2：从图像中裁剪一个区域。

变量data为指定输入图像中两个坐标点的4元组(x0,y0,x1,y1)。输出图像为这两个坐标点之间像素的采样结果。例如，如果输入图像的(x0,y0)为输出图像的（0，0）点，(x1,y1)则与变量size一样。

这个方法可以用于在当前图像中裁剪，放大，缩小或者镜像一个任意的长方形。它比方法crop()稍慢，但是与resize操作一样快。

定义3：im.transform(size, AFFINE, data) ⇒ image

im.transform(size, AFFINE,data, filter) ⇒ image

含义3：对当前的图像进行仿射变换，变换结果体现在给定尺寸的新图像中。

变量data是一个6元组(a,b,c,d,e,f)，包含一个仿射变换矩阵的第一个两行。输出图像中的每一个像素（x，y），新值由输入图像的位置（ax+by+c, dx+ey+f）的像素产生，使用最接近的像素进行近似。

这个方法用于原始图像的缩放、转换、旋转和裁剪。

例子3：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> im01.size

(1024, 768)

>>> trans3 =im01.transform((300,300), Image.AFFINE, (1,2,3,2,1,4))

>>> trans3.size

(300, 300)

定义4：im.transform(size,QUAD, data) ⇒ image

im.transform(size, QUAD, data, filter) ⇒ image

含义4：输入图像的一个四边形（通过四个角定义的区域）映射到给定尺寸的长方形。

变量data是一个8元组(x0,y0,x1,y1,x2,y2,x3,y3)，它包括源四边形的左上，左下，右下和右上四个角。

例子4：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> im01.size

(1024, 768)

>>> trans4 =im01.transform((300,300), Image.QUAD, (0,0,0,500,600,500,600,0))

>>> trans4.size

(300, 300)

定义5：im.transform(size,MESH, data) ⇒ image

im.transform(size, MESH, data, filter) ⇒ image

含义5：与QUAD类似，但是变量data是目标长方形和对应源四边形的list。

定义6：im.transform(size,PERSPECTIVE, data) ⇒ image

im.transform(size, PERSPECTIVE, data, filter) ⇒ image

含义6：对当前图像进行透视变换，产生给定尺寸的新图像。

变量data是一个8元组(a,b,c,d,e,f,g,h)，包括一个透视变换的系数。对于输出图像中的每个像素点，新的值来自于输入图像的位置的(a x + b y + c)/(g x + h y + 1), (d x+ e y + f)/(g x + h y + 1)像素，使用最接近的像素进行近似。

这个方法用于原始图像的2D透视。

例子6：

>>>from PIL import Image

>>> im01 =Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.size

(1024, 768)

>>> trans6= im01.transform((300,300), Image.PERSPECTIVE, (1,2,3,2,1,6,1,2))

>>>trans6.size

(300, 300)

34、 Transpose

定义：im.transpose(method)⇒ image

含义：返回当前图像的翻转或者旋转的拷贝。

变量method的取值为：FLIP_LEFT_RIGHT，FLIP_TOP_BOTTOM，ROTATE_90，ROTATE_180，或者ROTATE_270。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>> im= im01.transpose(Image.FLIP_LEFT_RIGHT)

图像im为图像im01的水平方向镜像。

35、Verify

定义：im.verify()

含义：尝试判断文件是否损坏，实际上并没有对图像数据进行解析。如果这个方法发现了任何问题，它将产生对应的异常。这个方法只工作于刚打开的图像；如果图像已经被加载，该方法的结果将会是未定义的。如果用户在使用这个方法后需要加载图像，用户需要重新打开图像文件。

注意：这个方法不能捕获所有的错误；要捕获解码错误，用户必须加载整个图像。

例子：

>>>from PIL import Image

>>>im01 = Image.open("D:\\Code\\Python\\test\\img\\test01.jpg")

>>>im01.verify()

没有任何输出，表示图像im01是没有损坏的。

首先，介绍一下PIL中的基本概念。

1、 通道

2、 模式

3、 尺寸

4、 坐标系统

5、 调色板

6、 信息

7、 滤波器

接着，说说PIL中的Image模块

一、Image类的属性

1、 Format

2、 Mode

3、 Size

4、 Palette

5、 Info

二、Image类的函数

1、 New

2、 Open

3、 Blend

4、 Composite

5、 Eval

6、 Frombuffer

7、 Fromstring

8、 Merge

三、Image类的方法

1、 Convert

2、 Copy

3、 Crop

4、 Draft

5、 Filter

6、 Fromstring

7、 Getbands

8、 Getbbox

9、 Getcolors

10、 Getdata

11、Getextrema

12、Getpixel

13、Histogram

14、Load

15、Offset

16、 Paste

17、 Point

18、 Putalpha

19、 Putdata

20、 Putpalette

21、 Putpixel

22、 Quantize

23、 Resize

24、 Rotate

25、Save

26、 Seek

27、 Show

28、 Split

29、 Tell

30、 Thumbnail

31、 Tobitmap

32、 Tostring

33、 Transform

34、 Transpose

35、Verify

1、通道

2、模式

3、尺寸

4、坐标系统

5、调色板

6、信息

7、滤波器