python图像处理pil

2018-05-17 11:33:18 wuguangbin1230 阅读数 16952
ImageDraw模块提供了图像对象的简单2D绘制。用户可以使用这个模块创建新的图像,注释或润饰已存在图像,为web应用实时产生各种图形。

PIL中一个更高级绘图库见The aggdraw Module

一、ImageDraw模块的概念

1、  Coordinates

绘图接口使用和PIL一样的坐标系统,即(00)为左上角。

2、  Colours

为了指定颜色,用户可以使用数字或者元组,对应用户使用函数Image.new或者Image.putpixel。对于模式为“1”,“L”和“I”的图像,使用整数。对于“RGB”图像,使用整数组成的3元组。对于“F”图像,使用整数或者浮点数。

对于调色板图像(模式为“P”),使用整数作为颜色索引。在1.1.4及其以后,用户也可以使用RGB 3元组或者颜色名称。绘制层将自动分配颜色索引,只要用户不绘制多于256种颜色。

3、  Colours Names

PIL 1.1.4及其以后的版本,用户绘制“RGB”图像时,可以使用字符串常量。PIL支持如下字符串格式:

A、 十六进制颜色说明符,定义为“#rgb”或者“#rrggbb”。例如,“#ff0000”表示纯红色。

B、 RGB函数,定义为“rgb(red, green, blue)”,变量redgreenblue的取值为[0255]之间的整数。另外,颜色值也可以为[0%100%]之间的三个百分比。例如,“rgb(255, 0, 0)”和“rgb(100%, 0%, 0%)”都表示纯红色。

C、 HSLHue-Saturation-Lightness)函数,定义为“hsl(hue,saturation%, lightness%)”,变量hue[0360]一个角度表示颜色(red=0 green=120 blue=240),变量saturation[0%100%]之间的一个值(gray=0%full color=100%),变量lightness[0%100%]之间的一个值(black=0% normal=50% white=100%)。例如,“hsl(0,100%, 50%)”为纯红色。

D、 通用HTML颜色名称,ImageDraw模块提供了140个标准颜色名称,Xwindow系统和大多数web浏览器都支持这些颜色。颜色名称对大小写不敏感。例如,“red”和“Red”都表示纯红色。

4、  Fonts

PIL可以使用bitmap字体或者OpenType/TrueType字体。

Bitmap字体被存储在PIL自己的格式中,它一般包括两个文件,一个叫.pil,它包含字体的矩阵,另一个通常叫做.pbm,它包含栅格数据。

ImageFont模块中,使用函数load()加载一个bitmap字体。

ImageFont模块中,使用函数truetype()加载一个OpenType/TrueType字体。注意:这个函数依赖于第三方库,而且并不是在所有的PIL版本中都有效。

IronPIL)加载内置的字体,使用ImageFont模块的Font()结构函数即可。

二、ImageDraw模块的函数

1、  Draw

定义:Draw(image) Draw instance

含义:创建一个可以在给定图像上绘图的对象。

IronPIL)用户可以使用ImageWin模块的HWND或者HDC对象来代替图像。这个允许用户直接在屏幕上绘图。

注意:图像内容将会被修改。

例子:

>>> fromPIL import Image, ImageDraw

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

>>> draw =ImageDraw.Draw(im01)

>>> draw.line((0,0) +im01.size, fill=128)

>>> draw.line((0,im01.size[1], im.size[0], 0), fill = 128)

>>> im01.show()

>>> del draw

在图像01上绘制了两条灰色的对角线,如下图:

                             

三、ImageDraw模块的方法

1、  Arc

定义:draw.arc(xy, start, end, options)

含义:在给定的区域内,在开始和结束角度之间绘制一条弧(圆的一部分)。

变量optionsfill设置弧的颜色。

例子:

>>> from PIL import Image,ImageDraw

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

>>> draw =ImageDraw.Draw(im01)

>>> draw.arc((0,0,200,200),0, 90, fill = (255,0,0))

>>>draw.arc((300,300,500,500), 0, -90, fill = (0,255,0))

>>> draw.arc((200,200,300,300),-90, 0, fill = (0,0,255))

>>> im01.show()

>>> del draw

注意:变量xy是需要设置一个区域,此处使用4元组,包含了区域的左上角和右下角两个点的坐标。此PIL版本中,变量options不能使用outline,会报错:“TypeError: arc() got an unexpected keyword argument 'outline'”;所以此处应该使用fill

在图像01(0,0,200,200)区域使用红色绘制了90度的弧,(300,300,500,500)区域使用绿色绘制了270度的弧,(200,200,300,300)区域使用蓝色绘制了90度的弧。这些弧都是按照顺时针方向绘制的。变量start/end0度为水平向右,沿着顺时针方向依次增加。绘制后的图像01如下图:

 

2、  Bitmap

定义:draw.bitmap(xy, bitmap, options)

含义:在给定的区域里绘制变量bitmap所对应的位图,非零部分使用变量optionsfill的值来填充。变量bitmap位图应该是一个有效的透明模板(模式为“1”)或者蒙版(模式为“L”或者“RGBA”)。

这个方法与Image.paste(xy, color, bitmap)有相同的功能。

例子:

>>> from PIL import Image,ImageDraw

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

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

>>> im =im02.resize(300,200)>>> im.size

(300, 200)

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

>>> draw =ImageDraw.Draw(im01)

>>>draw.bitmap((0,0), r, fill = (255,0,0))

>>>draw.bitmap((300,200), g, fill = (0,255,0))

>>>draw.bitmap((600,400), b, fill = (0,0,255))

>>> im01.show()

变量xy是变量bitmap对应位图起始的坐标值,而不是一个区域。

图像im01如下:

 

3、  Chord

定义:draw.chord(xy,start, end, options)

含义:和方法arc()一样,但是使用直线连接起始点。

变量optionsoutline给定弦轮廓的颜色。Fill给定弦内部的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>> draw =ImageDraw.Draw(im01)

>>> draw.chord((0,0,200,200),0, 90, fill = (255,0,0))

>>> draw.chord((300,300,500,500), 0, -90, fill = (0,255,0))

>>> draw.chord((200,200,300,300), -90, 0, fill = (0,0,255))

>>> im01.show()

图像im01如下:

 

4、  Ellipse

定义:draw.ellipse(xy,options)

含义:在给定的区域绘制一个椭圆形。

变量optionsoutline给定椭圆形轮廓的颜色。Fill给定椭圆形内部的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>> draw =ImageDraw.Draw(im01)

>>> draw.ellipse((0,0, 200, 200), fill = (255, 0, 0))

>>> draw.ellipse((200,200,400,300),fill = (0, 255, 0))

>>>draw.ellipse((400,400,800,600), fill = (0, 0, 255))

>>> im01.show()

图像im01如下:

 

5、  Line

定义:draw.line(xy,options)

含义:在变量xy列表所表示的坐标之间画线。

坐标列表可以是任何包含2元组[(x,y),…]或者数字[x,y,…]的序列对象。它至少包括两个坐标。

变量optionsfill给定线的颜色。

New in 1.1.5)变量optionswidth给定线的宽度。注意线连接不是很好,所以多段线段连接不好看。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>>draw.line([(0,0),(100,300),(200,500)], fill = (255,0,0), width = 5)

>>>draw.line([50,10,100,200,400,300], fill = (0,255,0), width = 10)

>>>im01.show()

图像im01如下:

 

6、  Pieslice

定义:draw.pieslice(xy,start, end, options)

含义:和方法arc()一样,但是在指定区域内结束点和中心点之间绘制直线。

变量optionsfill给定pieslice内部的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>>draw.pieslice((0,0,100,200), 0, 90, fill = (255,0,0))

>>>draw.pieslice((100,200,300,400), 0, -90, fill = (0,255,0))

>>> im01.show()

图像im01如下:

 

7、  Point

定义:draw.point(xy,options)

含义:在给定的坐标点上画一些点。

坐标列表是包含2元组[(x,y),…]或者数字[x,y,…]的任何序列对象。

变量optionsfill给定点的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>> draw.point([(0,0),(100,150), (110, 50)], fill = (255, 0, 0))

>>> draw.point([0,10,100,110, 210, 150], fill = (0, 255, 0))

>>>im01.show()

图像im01上在对应的坐标点上会有红色/绿色的点,每个点只占一个像素点。图像如下:

 

8、  Polygon

定义:draw.polygon(xy,options)

含义:绘制一个多边形。

多边形轮廓由给定坐标之间的直线组成,在最后一个坐标和第一个坐标间增加了一条直线,形成多边形。

坐标列表是包含2元组[(x,y),…]或者数字[x,y,…]的任何序列对象。它最少包括3个坐标值。

变量optionsfill给定多边形内部的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>> draw.polygon([(0,0),(100,150), (210, 350)], fill = (255, 0, 0))

>>> draw.polygon([300,300,100,400, 400, 400], fill = (0, 255, 0))

>>>im01.show()

图像01如下:

 

9、  Rectangle

定义:draw.rectangle(box,options)

含义:绘制一个长边形。

变量box是包含2元组[(x,y),…]或者数字[x,y,…]的任何序列对象。它应该包括2个坐标值。

注意:当长方形没有没有被填充时,第二个坐标对定义了一个长方形外面的点。

变量optionsfill给定长边形内部的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>>draw.rectangle((0,0,100,200), fill = (255,0,0))

>>> draw.rectangle([100,200,300,500],fill = (0,255,0))

>>>draw.rectangle([(300,500),(600,700)], fill = (0,0,255))

>>>im01.show()

图像01如下:

 

10、             Text

定义:draw.text(position,string, options)

含义:在给定的位置绘制一个字符创。变量position给出了文本的左上角的位置。

变量optionfont用于指定所用字体。它应该是类ImangFont的一个实例,使用ImageFont模块的load()方法从文件中加载的。

变量optionsfill给定文本的颜色。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>> draw.text((0,0),"Hello", fill = (255,0,0))

>>>im01.show()

在图像01(0,0)位置绘制出字符串“Hello”。

11、             Textsize

定义:draw.textsize(string,options) (width, height)

含义:返回给定字符串的大小,以像素为单位。

变量optionfont用于指定所用字体。它应该是类ImangFont的一个实例,使用ImageFont模块的load()方法从文件中加载的。

例子:

>>>from PIL import Image, ImageDraw

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

>>>draw = ImageDraw.Draw(im01)

>>>draw.textsize("Hello")

(30, 11)

>>>draw.textsize("Hello, the world")

(96, 11)

>>>im01.show()

四、ImageDraw模块的option变量

Option变量有三个属性,分别为outlinefillfontOutlinefill都可为整数或者元组;fontImageFont类的实例。

这几个属性在前面方法介绍中都有用到,这里不作解释。

五、ImageDraw模块的兼容性

Draw包括的一个构造函数和一些方法提供向后兼容。为了使这些函数正常工作,用户应该使用options,或者使用这些方法。但不能混合旧的和新的调用习惯。

IronPILIronPIL不支持这些有兼容性的方法。

1、  ImageDraw

定义:ImageDraw(image) Draw instance

含义:(不赞成)生成Draw的实例。新代码中不要用这个函数。

2、  Setink

定义:draw.setink(ink)

含义:(不赞成)为后续绘制和fill属性设置颜色。

3、   Setfill

定义:draw.setfill(mode)

含义:(不赞成)设置fill属性。

如果变量mode0,后续绘制的形状(像多边形和长方形)都是轮廓。如果mode1,则它们会被填充。

4、  Setfill

定义:draw.setfont(font)

含义:(不赞成)为text()方法设置默认的字体。

变量font是ImageFont类的实例,使用ImageFont模块的load()方法从文件中加载的。
2016-02-20 23:13:02 icamera0 阅读数 53962

(Image模块方法16-25)

16、  Paste

定义1im.paste(image,box)

含义1:将一张图粘贴到另一张图像上。变量box或者是一个给定左上角的2元组,或者是定义了左,上,右和下像素坐标的4元组,或者为空(与(00)一样)。如果给定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的(200200)和(500500)两个位置分别出现了裁剪出来的100x100的图像。其结果如下图所示:

                             

定义2im.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的(00)位置将出现一个100x100的绿色方块。

 

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

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

定义3im.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的(00)位置将出现一个半透明的100x100的方块。

定义4im.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的(00)位置将出现一个100x100的绿色方块。

17、  Point

定义1im.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)

用户可以省略变量scaleoffset

例子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中的每一个元素,并用一个列表给出返回值。如果funcNone,作用同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]

funcNone的情况,它的目的是将多个列表相同位置的元素归并到一个元组,在现在已经有了专用的函数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)]

 

定义2im.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对象中拷贝数据到当前图像,从图像的左上角(00)位置开始。变量scaleoffset用来调整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项整数,每组三个值表示对应像素的红,绿和蓝。用户可以使用768byte的字符串代替这个整数序列。

例子:

>>>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)。

变量filterNEARESTBILINEARBICUBIC或者ANTIALIAS之一。如果忽略,或者图像模式为“1”或者“P”,该变量设置为NEAREST

注意:在当前的版本中bilinearbicubic滤波器不能很好地适应大比例的下采样(例如生成缩略图)。用户需要使用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应该是NEARESTBILINEAR或者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)

图像im_30如下:

 

图像im_30_1如下:

 

 

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")

(未完待续)

2016-10-19 16:12:14 u010159842 阅读数 5529
用Python做图像处理
       最近在做一件比较 evil 的事情——验证码识别,以此来学习一些新的技能。因为我是初学,对图像处理方面就不太了解了,欲要利吾事,必先利吾器,既然只是做一下实验,那用 Python 来作原型开发再好不过了。在 Python 中,比较常用的图像处理库是 PIL(Python Image Library),当前版本是 1.1.6 ,用起来非常方便。大家可以在 http://www.pythonware.com/products/pil/index.htm 下载和学习。
       在这里,我主要是介绍一下做图像识别时可能会用到的一些 PIL 提供的功能,比如图像增强、还有滤波之类的。最后给出使用 Python 做图像处理与识别的优势与劣势。
基本图像处理
       使用 PIL 之前需要 import Image 模块:
import Image
       然后你就可以使用Image.open(‘xx.bmp’) 来打开一个位图文件进行处理了。打开文件你不用担心格式,也不用了解格式,无论什么格式,都只要把文件名丢给 Image.open 就可以了。真所谓 bmp、jpg、png、gif……,一个都不能少。
img = Image.open(‘origin.png’)    # 得到一个图像的实例对象 img
图 1原图
       图像处理中,最基本的就是色彩空间的转换。一般而言,我们的图像都是 RGB 色彩空间的,但在图像识别当中,我们可能需要转换图像到灰度图、二值图等不同的色彩空间。 PIL 在这方面也提供了极完备的支持,我们可以:
new_img = img.convert(‘L’)
把 img 转换为 256 级灰度图像, convert() 是图像实例对象的一个方法,接受一个 mode 参数,用以指定一种色彩模式,mode 的取值可以是如下几种:
· 1 (1-bit pixels, black and white, stored with one pixel per byte)
· L (8-bit pixels, black and white)
· P (8-bit pixels, mapped to any other mode using a colour palette)
· RGB (3x8-bit pixels, true colour)
· RGBA (4x8-bit pixels, true colour with transparency mask)
· CMYK (4x8-bit pixels, colour separation)
· YCbCr (3x8-bit pixels, colour video format)
· I (32-bit signed integer pixels)
· F (32-bit floating point pixels)
怎么样,够丰富吧?其实如此之处,PIL 还有限制地支持以下几种比较少见的色彩模式:LA (L with alpha), RGBX (true colour with padding) and RGBa (true colour with premultiplied alpha)。
下面看一下 mode 为 ‘1’、’L’、’P’时转换出来的图像:
图 2 mode = '1'
图 3 mode = 'L'
图 4 mode = 'P'
convert() 函数也接受另一个隐含参数 matrix,转换矩阵 matrix 是一个长度为4 或者16 tuple。下例是一个转换 RGB 空间到 CIE XYZ 空间的例子:
    rgb2xyz = (
        0.412453, 0.357580, 0.180423, 0,
        0.212671, 0.715160, 0.072169, 0,
        0.019334, 0.119193, 0.950227, 0 )
    out = im.convert("RGB", rgb2xyz)
       除了完备的色彩空间转换能力外, PIL 还提供了resize()、rotate()等函数以获得改变大小,旋转图片等几何变换能力,在图像识别方面,图像实例提供了一个 histogram() 方法来计算直方图,非常方便实用。
图像增强
       图像增强通常用以图像识别之前的预处理,适当的图像增强能够使得识别过程达到事半功倍的效果。 PIL 在这方面提供了一个名为 ImageEnhance 的模块,提供了几种常见的图像增强方案:
import ImageEnhance
enhancer = ImageEnhance.Sharpness(image)
for i in range(8):
    factor = i / 4.0
    enhancer.enhance(factor).show("Sharpness %f" % factor)
上面的代码即是一个典型的使用 ImageEnhance 模块的例子。 Sharpness 是 ImageEnhance 模块的一个类,用以锐化图片。这一模块主要包含如下几个类:Color、Brightness、Contrast和Sharpness。它们都有一个共同的接口 .enhance(factor) ,接受一个浮点参数 factor,标示增强的比例。下面看看这四个类在不同的 factor 下的效果
图 5 使用Color 进行色彩增强,factor 取值 [0, 4],步进 0.5
图 6 用 Birghtness 增强亮度,factor取值[0,4],步进0.5
图 7用 Contrast 增强对比度, factor 取值 [0,4],步进0.5
图 8用 Sharpness 锐化图像,factor取值 [0,4],步进0.5
图像 Filter
       PIL 在 Filter 方面的支持是非常完备的,除常见的模糊、浮雕、轮廓、边缘增强和平滑,还有中值滤波、ModeFilter等,简直方便到可以做自己做一个Photoshop。这些 Filter 都放置在 ImageFilter 模块中,ImageFilter主要包括两部分内容,一是内置的 Filter,如 BLUR、DETAIL等,另一部分是 Filter 函数,可以指定不同的参数获得不同的效果。示例如下:
import ImageFilter
im1 = im.filter(ImageFilter.BLUR)
im2 = im.filter(ImageFilter.MinFilter(3))
im3 = im.filter(ImageFilter.MinFilter()) # same as MinFilter(3)
可以看到 ImageFilter 模块的使用非常简单,每一个 Filter 都只需要一行代码就可调用,开发效率非常高。
 
图 9使用 BLUR
图 10使用 CONTOUR
图 11使用 DETAIL
图 12使用 EMBOSS
图 13使用 EDGE_ENHANCE
图 14使用 EDGE_ENHANCE_MORE
图 15使用 FIND_EDGES
图 16使用 SHARPEN
图 17使用 SMOOTH
图 18使用 SMOOTH_MORE
       以上是几种内置的 Filter 的效果图,除此之外, ImageFilter 还提供了一些 Filter 函数,下面我们来看看这些可以通过参数改变行为的 Filter 的效果:
图 19使用 Kernel(),参数:size = (3, 3), kernel = (0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5)
图 20使用 MaxFilter,默认参数
图 21使用 MinFilter,默认参数
图 22使用 MedianFilter,默认参数
图 23使用 ModeFilter,参数 size = 3
图 24使用 RankFilter,参数 size = 3, rank = 3
小结
       到此,对 PIL 的介绍就告一段落了。总的来说,对于图像处理和识别,PIL 内建了强大的支持,从各种增强算法到 Filter ,都让人无法怀疑使用 Python 的可行性。 Python唯一的劣势在于执行时间过慢,特别是当实现一些计算量大的算法时候,需要极强的耐心。我曾用 Hough Transform(霍夫变换)来查找图像中的直线,纯 Python 的实现处理一个 340 * 100 的图片也要花去数秒时间(P4 3.0G + 1G memory)。但使用 PIL 无需关注图像格式、内建的图像增强算法和 Filter 算法,这些优点使 Python 适合用于构造原型和进行实验,在这两方面Python 比 matlab 更加方便。商业的图像识别产品开发,可以考虑已经被 boost accepted的来自 adobe 的开源 C++ 库 gil,可以兼顾执行性能和开发效率。
2018-10-30 13:18:36 qq_36178899 阅读数 210

Python图像处理PIL各模块详细介绍

 

Image模块

Image模块是在Python PIL图像处理中常见的模块,对图像进行基础操作的功能基本都包含于此模块内。如opensaveconvershow…等功能。

open类

Image.open(file) ⇒ image 
Image.open(file, mode) ⇒ image

要从文件加载图像,使用 open() 函数, 在 Image 模块:

    @zhangziju
    from PIL import Image             ##调用库
    im = Image.open("E:\mywife.jpg")  ##文件存在的路径
    im.show()                         

我老婆

需要知道的是在win的环境下im.show的方式为win自带的图像显示应用。打开并确认给定的图像文件。这个是一个懒操作;该函数只会读文件头,而真实的图像数据直到试图处理该数据才会从文件读取(调用load()方法将强行加载图像数据)。如果变量mode被设置,那必须是“r”。用户可以使用一个字符串(表示文件名称的字符串)或者文件对象作为变量file的值。文件对象必须实现read(),seek()和tell()方法,并且以二进制模式打开。

Save类

im.save(outfile,options…) 
im.save(outfile, format, options…)

若要保存文件,则使用 Image 类的 save() 方法,此时保存文件的文件名就变得十分重要了,除非指定格式,否则这个库将会以文件名的扩展名作为格式保存。使用给定的文件名保存图像。如果变量format缺省,如果可能的话,则从文件名称的扩展名判断文件的格式。该方法返回为空。关键字options为文件编写器提供一些额外的指令。如果编写器不能识别某个选项,它将忽略它。用户可以使用文件对象代替文件名称。在这种情况下,用户必须指定文件格式。文件对象必须实现了seek()、tell()和write()方法,且其以二进制模式打开。如果方法save()因为某些原因失败,这个方法将产生一个异常(通常为IOError异常)。如果发生了异常,该方法也有可能已经创建了文件,并向文件写入了一些数据。如果需要的话,用户的应用程序可以删除这个不完整的文件。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im)
im.save("E:\mywife.png")     ## 将"E:\mywife.jpg"保存为"E:\mywife.png"
im = Image.open("E:\mywife.png")  ##打开新的png图片
print(im.format, im.size, im.mode)

这里写图片描述 
如下图,在指定路径下可看到新保存的png格式的图片。 
新的png图片

format类

im.format ⇒ string or None

这个属性标识了图像来源,如果图像不是从文件读取它的值就是None。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.format) ## 打印出格式信息
im.show()

如下图可以看到其format为”JPEG”。

format

Mode类

im.mode ⇒ string

图像的模式,常见的mode 有 “L” (luminance) 表示灰度图像,“RGB”表示真彩色图像,和 “CMYK” 表示出版图像,表明图像所使用像素格式。如下表为常见的nodes描述:

modes 描述
1 1位像素,黑和白,存成8位的像素
L 8位像素,黑白
P 8位像素,使用调色板映射到任何其他模式
RGB 3× 8位像素,真彩
RGBA 4×8位像素,真彩+透明通道
CMYK 4×8位像素,颜色隔离
YCbCr 3×8位像素,彩色视频格式
I 32位整型像素
F 32位浮点型像素
@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.mode) ## 打印出模式信息
im.show()

如下图为图片的mode为“RGB”模式。

mode

convert类

im.convert(mode)⇒ image

将当前图像转换为其他模式,并且返回新的图像。当从一个调色板图像转换时,这个方法通过这个调色板来转换像素。如果不对变量mode赋值,该方法将会选择一种模式,在没有调色板的情况下,使得图像和调色板中的所有信息都可以被表示出来。当从一个颜色图像转换为黑白图像时,PIL库使用ITU-R601-2 luma转换公式:

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

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

from PIL import Image
im = Image.open("E:\mywife.jpg")
new_im = im.convert('P')
print(new_im.mode)
new_im.show()

如下,将图像转换为“P”模式。

这里写图片描述 
对比原始图像。

这里写图片描述

im.convert(“P”,**options) ⇒ image

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

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

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

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

im.convert(mode,matrix) ⇒ image

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


from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.mode)
rgb2xyz = (0.412453,0.357580, 0.180423, 0,
           0.212671,0.715160, 0.072169, 0,
           0.019334,0.119193, 0.950227, 0 )
new_im = im.convert("L", rgb2xyz)
print(new_im.mode)
new_im.show()

这里写图片描述 
转换后效果

这里写图片描述

Size类

im.size ⇒ (width, height)

图像的尺寸,按照像素数计算,它的返回值为宽度和高度的二元组(width, height)。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.size) ## 打印出尺寸信息
im.show()
  •  

如下图所示为图片的尺寸信息,750*560。

这里写图片描述

Palette类

im.palette ⇒ palette or None

颜色调色板表格。如果图像的模式是“P”,则返回ImagePalette类的实例;否则,将为None。 
如下为对非“P”模式下的图像进行palette信息显示。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.palette)

易知,返回值为空,none

这里写图片描述 
对图像进行convert操作,转换成“P”模式

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
new_im = im.convert('P')
print(new_im.mode)
print(new_im.palette)

则返回值为ImagePalette类的实例。如下:

这里写图片描述

Info类

im.info ⇒ dictionary

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

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.info)

这里写图片描述

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。这对向该图像复制或绘制某些内容是有用的。

如下为将图像设置为128x128大小的红色图像。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
n_im= Image.new("RGB", (128, 128), "#FF0000")
n_im.show()

显示效果如下:

这里写图片描述 
如下图像为128x128大小的黑色图像,因为变量color不赋值的话,图像内容被设置为0,即黑色。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
n_im= Image.new("RGB", (128, 128))
n_im.show()

黑 
图像为128x128大小的绿色图像。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
n_im= Image.new("RGB", (128, 128),"green")
n_im.show()

这里写图片描述

Copy类

im.copy() ⇒ image

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


from PIL import Image
im = Image.open("E:\mywife.jpg")
im_copy = im.copy()

图像im_copy和im完全一样。

Crop类

im.crop(box) ⇒ image

从当前的图像中返回一个矩形区域的拷贝。变量box是一个四元组,定义了左、上、右和下的像素坐标。用来表示在原始图像中截取的位置坐标,如box(100,100,200,200)就表示在原始图像中以左上角为坐标原点,截取一个100*100(像素为单位)的图像,为方便理解,如下为示意图box(b1,a1,b2,a2)。作图软件为Visio2016。这是一个懒操作。对源图像的改变可能或者可能不体现在裁减下来的图像中。为了获取一个分离的拷贝,对裁剪的拷贝调用方法load()。

box区域示意图

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
box = (300, 100, 700, 700)              ##确定拷贝区域大小
region = im.crop(box)                   ##将im表示的图片对象拷贝到region中,大小为box
region.show()

如下图为box截取的图像区域显示。

box区域图

Paste类

im.paste(image,box)

将一张图粘贴到另一张图像上。变量box或者是一个给定左上角的2元组,或者是定义了左,上,右和下像素坐标的4元组,或者为空(与(0,0)一样)。如果给定4元组,被粘贴的图像的尺寸必须与区域尺寸一样。如果模式不匹配,被粘贴的图像将被转换为当前图像的模式。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
box=[0,0,100,100]
im_crop = im.crop(box)
print(im_crop.size,im_crop.mode)
im.paste(im_crop, (100,100))             ##(100,100,0,0)
im.paste(im_crop, (400,400,500,500))
im.show()
  •  

如下图为paste操作:

这里写图片描述

Filter类

im.filter(filter) ⇒ image

返回一个使用给定滤波器处理过的图像的拷贝。具体参考图像滤波在ImageFilter 模块的应用,在该模块中,预先定义了很多增强滤波器,可以通过filter( )函数使用,预定义滤波器包括:BLUR、CONTOUR、DETAIL、EDGE_ENHANCE、EDGE_ENHANCE_MORE、EMBOSS、FIND_EDGES、SMOOTH、SMOOTH_MORE、SHARPEN。其中BLUR就是均值滤波,CONTOUR找轮廓,FIND_EDGES边缘检测,使用该模块时,需先导入。

@zhangziju
from PIL import Image
from PIL import ImageFilter                         ## 调取ImageFilter
imgF = Image.open("E:\mywife.jpg")
bluF = imgF.filter(ImageFilter.BLUR)                ##均值滤波
conF = imgF.filter(ImageFilter.CONTOUR)             ##找轮廓
edgeF = imgF.filter(ImageFilter.FIND_EDGES)         ##边缘检测
imgF.show()
bluF.show()
conF.show()
edgeF.show()

滤波处理下的gakki~

滤波

Blend类

Image.blend(image1,image2, alpha) ⇒ image

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

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

若变量alpha为0.0,返回第一张图像的拷贝。若变量alpha为1.0,将返回第二张图像的拷贝。对变量alpha的值无限制。

@zhangziju
from PIL import Image
im1 = Image.open("E:\mywife.jpg")
im2 = Image.open("E:\mywife2.jpg")
print(im1.mode,im1.size)
print(im2.mode,im2.size)
im = Image.blend(im1, im2, 0.2)
im.show()

需保证两张图像的模式和大小是一致的,如下为显示im1和im2的具体信息。

这里写图片描述 
im1和im2按照第一张80%的透明度,第二张20%的透明度,合成为一张。 
这里写图片描述

Split

im.split() ⇒ sequence

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

from PIL import Image
im = Image.open("E:\mywife.jpg")
r,g,b = im.split()
print(r.mode)
print(r.size)
print(im.size)

这里写图片描述

Composite类

Image.composite(image1,image2, mask) ⇒ image

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

@zhangziju
from PIL import Image
im1 = Image.open("E:\mywife.jpg")
im2 = Image.open("E:\mywife2.jpg")
r,g,b = im1.split()             ##分离出r,g,b
print(b.mode)
print(im1.mode,im1.size)
print(im2.mode,im2.size)
im = Image.composite(im1,im2,b)
im.show()

b.mode为”L”,两图尺寸一致。

这里写图片描述 
最终效果

这里写图片描述

Eval类

Image.eval(image,function) ⇒ image

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

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
def fun01(x):
    return x*0.3
def fun02(y):
    return y*2.0
im1_eval = Image.eval(im, fun01)
im2_eval = Image.eval(im, fun02)
im1_eval.show()
im2_eval.show()

在函数fun01和fun02下的图像显示。

这里写图片描述

Merge类

Image.merge(mode,bands) ⇒ image

合并类使用一些单通道图像,创建一个新的图像。变量bands为一个图像的元组或者列表,每个通道的模式由变量mode描述。所有通道必须有相同的尺寸。 
变量mode与变量bands的关系:

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

@zhangziju
from PIL import Image
im1 = Image.open("E:\mywife.jpg")
im2 = Image.open("E:\mywife2.jpg")
r1,g1,b1 = im1.split()
r2,g2,b2 = im2.split()
print(r1.mode,r1.size,g1.mode,g1.size)
print(r2.mode,r2.size,g2.mode,g2.size)
new_im=[r1,g2,b2]
print(len(new_im))
im_merge = Image.merge("RGB",new_im)
im_merge.show()

打印信息显示

这里写图片描述 
merge操作

这里写图片描述

Draft类

im.draft(mode,size)

配置图像文件加载器,使得返回一个与给定的模式和尺寸尽可能匹配的图像的版本。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.size,im.mode)
new_im = im.draft("L", (200,200))
print(new_im.size,new_im.mode)
new_im.show()

关键信息显示

这里写图片描述 
转换效果

这里写图片描述

Getbands类

im.getbands()⇒ tuple of strings

返回包括每个通道名称的元组。例如,对于RGB图像将返回(“R”,“G”,“B”)。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.getbands())

这里写图片描述

Getbbox类

im.getbbox() ⇒ 4-tuple or None

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

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.getbbox())

这里写图片描述

Getdata类

im.getdata() ⇒ sequence

以包含像素值的sequence对象形式返回图像的内容。这个sequence对象是扁平的,以便第一行的值直接跟在第零行的值后面,等等。这个方法返回的sequence对象是PIL内部数据类型,它只支持某些sequence操作,包括迭代和基础sequence访问。使用list(im.getdata()),将它转换为普通的sequence。Sequence对象的每一个元素对应一个像素点的R、G和B三个值。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
sequ = im.getdata()
sequ0 = list(sequ)
print(sequ0[0])
print(sequ0[1])
print(sequ0[2])

可视化显示sequence0里面的数据。

这里写图片描述 
打印显示结果,与前面对比。

这里写图片描述

Getextrema类

im.getextrema() ⇒ 2-tuple

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

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.getextrema())
  • 返回了R/G/B三个通道的最小和最大值的2元组。

这里写图片描述

Getpixel类

im.getpixel(xy) ⇒ value or tuple

返回给定位置的像素值。如果图像为多通道,则返回一个元组。该方法执行比较慢;如果用户需要使用python处理图像中较大部分数据,可以使用像素访问对象(见load),或者方法getdata()。

@zahngziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.getpixel((0,0)))
print(im.getpixel((4,0)))
r,g,b = im.split()
print(b.getpixel((11,8)))   

这里写图片描述

Histogram类

im.histogram()⇒ list

返回一个图像的直方图。这个直方图是关于像素数量的list,图像中的每个象素值对应一个成员。如果图像有多个通道,所有通道的直方图会连接起来(例如,“RGB”图像的直方图有768个值)。二值图像(模式为“1”)当作灰度图像(模式为“L”)处理。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
imhis = im.histogram()
print(len(imhis))
print(imhis[0])
print(imhis[150])
print(imhis[300])

这里写图片描述

im.histogram(mask)⇒ list

返回图像中模板图像非零地方的直方图。模板图像与处理图像的尺寸必须相同,并且要么是二值图像(模式为“1”),要么为灰度图像(模式为“L”)。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
r,g,b = im.split()
imhis = im.histogram()
print(r.mode)
print(len(imhis))
print(imhis[0])
print(imhis[150])
print(imhis[300])

这里写图片描述

Load类

im.load()

为图像分配内存并从文件中加载它(或者从源图像,对于懒操作)。正常情况下,用户不需要调用这个方法,因为在第一次访问图像时,Image类会自动地加载打开的图像。在1.1.6及以后的版本,方法load()返回一个用于读取和修改像素的像素访问对象。这个访问对象像一个二维队列,如:

pix = im.load() 
print pix[x, y] 
pix[x, y] =value

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

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
pix = im.load()
print(pix[0,2])

这里写图片描述

im.paste(colour,box)

使用同一种颜色填充变量box对应的区域。对于单通道图像,变量colour为单个颜色值;对于多通道,则为一个元组。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
im.paste((256,256,0),(0,0,100,100))  ##(256,256,0)表示黄色
im.show()

这里写图片描述

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
im.paste("blue",(0,0,100,100))   ##或者“blue”
im.show()

这里写图片描述

im.paste(image,box, mask)

使用变量mask对应的模板图像来填充所对应的区域。可以使用模式为“1”、“L”或者“RGBA”的图像作为模板图像。模板图像的尺寸必须与变量image对应的图像尺寸一致。如果变量mask对应图像的值为255,则模板图像的值直接被拷贝过来;如果变量mask对应图像的值为0,则保持当前图像的原始值。变量mask对应图像的其他值,将对两张图像的值进行透明融合,如果变量image对应的为“RGBA”图像,即粘贴的图像模式为“RGBA”,则alpha通道被忽略。用户可以使用同样的图像作为原图像和模板图像

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
box=[300,300,400,400]
im_crop =im.crop(box)
r,g,b =im_crop.split()
im.paste(im_crop, (200,200,300,300), r)
im.show()

这里写图片描述

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。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
r, g, b = im.split()
print(
r.getpixel((0, 0)),
r.getpixel((1, 0)),
r.getpixel((2, 0)),
r.getpixel((3, 0)),
r.putdata([1, 2, 3, 4]),
r.getpixel((0, 0)),
r.getpixel((1, 0)),
r.getpixel((2, 0)),
r.getpixel((3, 0)),
)

这里写图片描述

Resize类

im.resize(size) ⇒ image 
im.resize(size, filter) ⇒ image

返回改变尺寸的图像的拷贝。变量size是所要求的尺寸,是一个二元组:(width, height)。变量filter为NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果忽略,或者图像模式为“1”或者“P”,该变量设置为NEAREST。在当前的版本中bilinear和bicubic滤波器不能很好地适应大比例的下采样(例如生成缩略图)。用户需要使用ANTIALIAS,除非速度比质量更重要。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
region = im.resize((400, 400))     ##重新设定大小
region.show()

很明显由于大小的重新设定,图片的显示效果有所转变,gakki依然美腻~ 
设定大小

Rotate类

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

返回一个按照给定角度顺时钟围绕图像中心旋转后的图像拷贝。变量filter是NEAREST、BILINEAR或者BICUBIC之一。如果省略该变量,或者图像模式为“1”或者“P”,则默认为NEAREST。变量expand,如果为true,表示输出图像足够大,可以装载旋转后的图像。如果为false或者缺省,则输出图像与输入图像尺寸一样大。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
im_45 = im.rotate(45)
im_30 = im.rotate(30, Image.NEAREST,1)
print(im_45.size,im_30.size)
im_45.show()
im_30.show()

这里写图片描述

这里写图片描述

Seek类

im.seek(frame)

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

@zhangziju
from PIL import Image
im_gif = Image.open("E:\mywife.gif")
print(im_gif.mode)
im_gif.show()    ##第0帧
im_gif.seek(3)
im_gif.show()
im_gif.seek(9)
im_gif.show()
  • 1
  •  

来来来~这是gakki原图欣赏下~

这里写图片描述 
查找帧seek()的效果如下:

这里写图片描述

Tell类

im.tell() ⇒ integer

返回当前帧所处位置,从0开始计算。

@zhangziju
from PIL import Image
im_gif = Image.open("E:\mywife.gif")
print(im_gif.tell())
im_gif.seek(8)
print(im_gif.tell())

这里写图片描述

Thumbnail类

im.thumbnail(size) 
im.thumbnail(size, filter)

修改当前图像,使其包含一个自身的缩略图,该缩略图尺寸不大于给定的尺寸。这个方法会计算一个合适的缩略图尺寸,使其符合当前图像的宽高比,调用方法draft()配置文件读取器,最后改变图像的尺寸。变量filter应该是NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果省略该变量,则默认为NEAREST。注意:在当前PIL的版本中,滤波器bilinear和bicubic不能很好地适应缩略图产生。用户应该使用ANTIALIAS,图像质量最好。如果处理速度比图像质量更重要,可以选用其他滤波器。这个方法在原图上进行修改。如果用户不想修改原图,可以使用方法copy()拷贝一个图像。这个方法返回空。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
im.thumbnail((100,100))

Transform类

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

使用给定的尺寸生成一张新的图像,与原图有相同的模式,使用给定的转换方式将原图数据拷贝到新的图像中。在当前的PIL版本中,参数method为EXTENT(裁剪出一个矩形区域),AFFINE(仿射变换),QUAD(将正方形转换为矩形),MESH(一个操作映射多个正方形)或者PERSPECTIVE。变量filter定义了对原始图像中像素的滤波器。在当前的版本中,变量filter为NEAREST、BILINEAR、BICUBIC或者ANTIALIAS之一。如果忽略,或者图像模式为“1”或者“P”,该变量设置为NEAREST。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.size)
imtra = im.transform((200, 200), Image.EXTENT, (0, 0, 500, 500))
print(imtra.size)
imtra.show()

这里写图片描述

这里写图片描述

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

从图像中裁剪一个区域。变量data为指定输入图像中两个坐标点的4元组(x0,y0,x1,y1)。输出图像为这两个坐标点之间像素的采样结果。例如,如果输入图像的(x0,y0)为输出图像的(0,0)点,(x1,y1)则与变量size一样。这个方法可以用于在当前图像中裁剪,放大,缩小或者镜像一个任意的长方形。它比方法crop()稍慢,但是与resize操作一样快。

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

对当前的图像进行仿射变换,变换结果体现在给定尺寸的新图像中。变量data是一个6元组(a,b,c,d,e,f),包含一个仿射变换矩阵的第一个两行。输出图像中的每一个像素(x,y),新值由输入图像的位置(ax+by+c, dx+ey+f)的像素产生,使用最接近的像素进行近似。这个方法用于原始图像的缩放、转换、旋转和裁剪。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.size)
imtra = im.transform((200, 200), Image.AFFINE, (1,2,3,2,1,4))
print(imtra.size)
imtra.show()

这里写图片描述 
这里写图片描述

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

输入图像的一个四边形(通过四个角定义的区域)映射到给定尺寸的长方形。变量data是一个8元组(x0,y0,x1,y1,x2,y2,x3,y3),它包括源四边形的左上,左下,右下和右上四个角。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.size)
imtra = im.transform((200, 200), Image.QUAD, (0,0,0,500,600,500,600,0))
print(imtra.size)
imtra.show()

这里写图片描述 
这里写图片描述

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

对当前图像进行透视变换,产生给定尺寸的新图像。变量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透视。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
print(im.size)
imtra = im.transform((200, 200), Image.PERSPECTIVE, (1,2,3,2,1,6,1,2))
print(imtra.size)
imtra.show()

这里写图片描述 
wocao!!!gakki不见了!!!

这里写图片描述

Transpose类

im.transpose(method)⇒ image

返回当前图像的翻转或者旋转的拷贝。变量method的取值为:FLIP_LEFT_RIGHT,FLIP_TOP_BOTTOM,ROTATE_90,ROTATE_180,或ROTATE_270。

@zhangziju
from PIL import Image
im = Image.open("E:\mywife.jpg")
im.rotate(45)                             #逆时针旋转 45 度角。
im.transpose(Image.FLIP_LEFT_RIGHT)       #左右对换。
im.transpose(Image.FLIP_TOP_BOTTOM)       #上下对换。
im.transpose(Image.ROTATE_90)             #旋转 90 度角。
im.transpose(Image.ROTATE_180)            #旋转 180 度角。
im.transpose(Image.ROTATE_270)            #旋转 270 度角。
2016-03-10 08:16:02 icamera0 阅读数 132184

在数字图像处理中,针对不同的图像格式有其特定的处理算法。所以,在做图像处理之前,我们需要考虑清楚自己要基于哪种格式的图像进行算法设计及其实现。本文基于这个需求,使用python中的图像处理库PIL来实现不同图像格式的转换。

对于彩色图像,不管其图像格式是PNG,还是BMP,或者JPG,在PIL中,使用Image模块的open()函数打开后,返回的图像对象的模式都是“RGB”。而对于灰度图像,不管其图像格式是PNG,还是BMP,或者JPG,打开后,其模式为“L”。

通过之前的博客对Image模块的介绍,对于PNGBMPJPG彩色图像格式之间的互相转换都可以通过Image模块的open()save()函数来完成。具体说就是,在打开这些图像时,PIL会将它们解码为三通道的“RGB”图像。用户可以基于这个“RGB”图像,对其进行处理。处理完毕,使用函数save(),可以将处理结果保存成PNGBMPJPG中任何格式。这样也就完成了几种格式之间的转换。同理,其他格式的彩色图像也可以通过这种方式完成转换。当然,对于不同格式的灰度图像,也可通过类似途径完成,只是PIL解码后是模式为“L”的图像。

这里,我想详细介绍一下Image模块的convert()函数,用于不同模式图像之间的转换。

Convert()函数有三种形式的定义,它们定义形式如下:

im.convert(mode) image

im.convert(“P”, **options) image

im.convert(mode, matrix) image

使用不同的参数,将当前的图像转换为新的模式,并产生新的图像作为返回值。

通过博客“Python图像处理库PIL的基本概念介绍”,我们知道PIL中有九种不同模式。分别为1LPRGBRGBACMYKYCbCrIF

本文我采用的示例图像是图像处理中经典的lena照片。分辨率为512x512lena图片如下:

一、模式“RGB”转换为其他不同模式

1、 模式“1

模式“1”为二值图像,非黑即白。但是它每个像素用8bit表示,0表示黑,255表示白。下面我们将lena图像转换为“1”图像。

例子:

>>>from PIL import Image

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

>>> lena.mode

'RGB'

>>> lena.getpixel((0,0))

(197, 111, 78)

>>> lena_1 = lena.convert("1")

>>> lena_1.mode

'1'

>>> lena_1.size

(512, 512)

>>>lena_1.getpixel((0,0))

255

>>> lena_1.getpixel((10,10))

255

>>>lena_1.getpixel((10,120))

0

>>>lena_1.getpixel((130,120))

255

 

图像lena_1的模式为“1”,分辨率为512x512,如下:

2、 模式“L

模式“L”为灰色图像,它的每个像素用8bit表示,0表示黑,255表示白,其他数字表示不同的灰度。在PIL中,从模式“RGB”转换为“L”模式是按照下面的公式转换的:

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

下面我们将lena图像转换为“L”图像。

例子:

>>> from PIL importImage

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

>>> lena.mode

'RGB'

>>> lena.getpixel((0,0))

(197, 111, 78)

>>> lena_L =lena.convert("L")

>>> lena_L.mode

'L'

>>> lena_L.size

(512, 512)

>>>lena.getpixel((0,0))

(197, 111, 78)

>>>lena_L.getpixel((0,0))

132

对于第一个像素点,原始图像lena(197, 111, 78),其转换为灰色值为:

197 *299/1000 + 111 * 587/1000 + 78 * 114/1000 = 132.952PIL中只取了整数部分,即为132

转换后的图像lena_L如下:

3、 模式“P

模式“P”为8位彩色图像,它的每个像素用8bit表示,其对应的彩色值是按照调色板查询出来的。

下面我们使用默认的调色板将lena图像转换为“P”图像。

例子:

>>> from PIL importImage

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

>>> lena.mode

'RGB'

>>> lena.getpixel((0,0))

(197, 111, 78)

>>> lena_P =lena.convert("P")

>>> lena_P.mode

'P'

>>>lena_P.getpixel((0,0))

62

 

转换后的图像lena_P如下:

4、 模式“RGBA

模式“RGBA”为32位彩色图像,它的每个像素用32bit表示,其中24bit表示红色、绿色和蓝色三个通道,另外8bit表示alpha通道,即透明通道。

下面我们将模式为“RGB”的lena图像转换为“RGBA”图像。

例子: 

                                                                                                                              

>>> from PIL import Image

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

>>>lena.mode

'RGB'

>>>lena.getpixel((0,0))

(197,111, 78)

>>>lena_rgba = lena.convert("RGBA")

>>>lena_rgba.mode

'RGBA'

>>>lena_rgba.getpixel((0,0))

(197,111, 78, 255)

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

(196,110, 77, 255)

>>>lena.getpixel((0,0))

(197,111, 78)

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

(196,110, 77)

 

从实例中可以看到,使用当前这个方式将“RGB”图像转为“RGBA”图像时,alpha通道全部设置为255,即完全不透明。

转换后的图像lena_rgba如下:

5、 模式“CMYK

模式“CMYK”为32位彩色图像,它的每个像素用32bit表示。模式CMYK”就是印刷四分色模式,它是彩色印刷时采用的一种套色模式,利用色料的三原色混色原理,加上黑色油墨,共计四种颜色混合叠加,形成所谓“全彩印刷”。

四种标准颜色是:CCyan = 青色,又称为‘天蓝色’或是‘湛蓝’MMagenta = 品红色,又称为‘洋红色’;YYellow = 黄色;KKey Plate(blacK) = 定位套版色(黑色)。

下面我们将模式为“RGB”的lena图像转换为“CMYK”图像。

例子:

>>>from PIL import Image

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

>>> lena_cmyk =lena.convert("CMYK")

>>> lena_cmyk.mode

'CMYK'

>>>lena_cmyk.getpixel((0,0))

(58, 144, 177, 0)

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

(59, 145, 178, 0)

>>>lena.getpixel((0,0))

(197, 111, 78)

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

(196, 110, 77)

 

从实例中可以得知PIL中“RGB”转换为“CMYK”的公式如下:

C = 255 - R
M = 255 - G
Y = 255 - B
K = 0

由于该转换公式比较简单,转换后的图像颜色有些失真。

转换后的图像lena_cmyk如下:

6、 模式“YCbCr

模式“YCbCr”为24位彩色图像,它的每个像素用24bit表示。YCbCr其中Y是指亮度分量,Cb指蓝色色度分量,而Cr指红色色度分量。人的肉眼对视频的Y分量更敏感,因此在通过对色度分量进行子采样来减少色度分量后,肉眼将察觉不到的图像质量的变化。

模式“RGB”转换为“YCbCr”的公式如下:

Y= 0.257*R+0.504*G+0.098*B+16
Cb = -0.148*R-0.291*G+0.439*B+128
Cr = 0.439*R-0.368*G-0.071*B+128

下面我们将模式为“RGB”的lena图像转换为“YCbCr”图像。

例子:

>>>from PIL import Image

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

>>> lena_ycbcr =lena.convert("YCbCr")

>>>lena_ycbcr.mode

'YCbCr'

>>>lena_ycbcr.getpixel((0,0))

(132, 97, 173)

>>>lena.getpixel((0,0))

(197, 111, 78)

 

按照公式,Y = 0.257*197+0.564*111+0.098*78+16= 136.877

Cb= -0.148*197-0.291*111+0.439*78+128= 100.785
Cr = 0.439*197-0.368*111-0.071*78+128 = 168.097

由此可见,PIL中并非按照这个公式进行“RGB”到“YCbCr”的转换。

转换后的图像lena_ycbcr如下:

7、 模式“I

模式“I”为32位整型灰色图像,它的每个像素用32bit表示,0表示黑,255表示白,(0,255)之间的数字表示不同的灰度。在PIL中,从模式“RGB”转换为“I”模式是按照下面的公式转换的:

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

下面我们将模式为“RGB”的lena图像转换为“I”图像。

例子:

>>> from PIL import Image

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

>>>lena.getpixel((0,0))

(197,111, 78)

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

(196,110, 77)

>>> lena_I =lena.convert("I")

>>> lena_I.mode

'I'

>>>lena_I.getpixel((0,0))

132

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

131

>>> lena_L =lena.convert("L")

>>>lena_L.getpixel((0,0))

132

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

131

 

从实验的结果看,模式“I”与模式“L”的结果是完全一样,只是模式“L”的像素是8bit,而模式“I”的像素是32bit

8、 模式“F

模式“F”为32位浮点灰色图像,它的每个像素用32bit表示,0表示黑,255表示白,(0,255)之间的数字表示不同的灰度。在PIL中,从模式“RGB”转换为“F”模式是按照下面的公式转换的:

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

下面我们将模式为“RGB”的lena图像转换为“F”图像。

例子:

>>>from PIL import Image

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

>>>lena.getpixel((0,0))

(197, 111, 78)

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

(196, 110, 77)

>>> lena_F =lena.convert("F")

>>> lena_F.mode

'F'

>>>lena_F.getpixel((0,0))

132.95199584960938

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

131.95199584960938

 

模式“F”与模式“L”的转换公式是一样的,都是RGB转换为灰色值的公式,但模式“F”会保留小数部分,如实验中的数据。

(未完待续)