RGB模式的图像中每个像素的颜色值都有R、G、B三个数值来决定，每个数值的范围是0到255。当R、G、B 数值相

Posted 2023-04-17

RGB模式的图像中每个像素的颜色值都有R、G、B三个数值来决定，每个数值的范围是0到255。当R、G、B 数值相等、均为255、均为0时，最终的颜色分别是： A．中性灰色、纯白色、纯黑色 B．偏色的灰

RGB模式的图像中每个像素的颜色值都有R、G、B三个数值来决定，每个数值的范围是0到255。当R、G、B 数值相等、均为255、均为0时，最终的颜色分别是：A．中性灰色、纯白色、纯黑色B．偏色的灰色、纯白色、纯黑色C．中性灰色、纯黑色、纯白色D．偏色的灰色、纯黑色、纯白色 参考技术A 偏色的灰色、纯白色、纯黑色

Python3 集成Pillow

1.安装pillow

pip install pillow

2.图像处理简介

图像处理RGB色彩模式：

-R(red)      0--255

-G(green)  0--255

-B(blue)     0--255

像素阵列

每个点就是一个像素每个点都由（R,G,B）表示颜色

图片素材：

 

3.模块介绍

A.Image模块

(1)打开图片

例：用Image打开一张图片

#导入模块
from PIL import Image
#打开图片
img=Image.open('kiki.jpg')
#显示图片
img.show()
print('图片格式：',img.format)
print('图片大小：',img.size)
print('高度：',img.height)
print('宽度：',img.width)
print('(100,100)处的RGB：',img.getpixel((100,100)))
'''
图片格式 JPEG
图片大小 (500, 330)
高度 330
宽度 500
(100,100)处的RGB (2, 6, 5)
'''

(2)混合

①透明度混合

blend(im1,im2,alpha)

im1:图1，im2:图2，alpha混合透明度（0-1）为im2的占比

注意：im1,im2的尺寸需要相同

具体混合的公式：im1*(1-alpha)+im2*alpha

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
img2=Image.open('yoki.jpg')
#图片混合
img1add2=Image.blend(img1,img2,0.5)
#显示图片
img1add2.show()

混合结果

 

②遮罩混合

composite(im1,im2,mask)

功能：使用mask来混合处理im1，im2，要求im1，im2，mask三幅图片尺寸相同。

#导入模块
from PIL import Image
#打开图片并变成相同尺寸（这里本来就相同）
img1=Image.open('kiki.jpg')
img2=Image.open('yoki.jpg').resize(img1.size)
img3=Image.open('niki.jpg').resize(img1.size)
#把img3的rgb分离
r3,g3,b3=img3.split()
img1composite2=Image.composite(img1,img2,b3)
#显示图片
img1composite2.show()

 结果：

（3）图像缩放

①像素缩放（其实是调亮度）：

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
#将每个像素值扩大2倍
img1_mul2=Image.eval(img1,lambda x:x*2)
#显示图片
img1_mul2.show()

结果：

②尺寸缩放（改变大小）:

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
img2=img1.copy()
#将每个像素值缩小一半
img2.thumbnail((img1.size[0]/2,img1.size[1]/2))
#显示图片大小
print('img1:',img1.size)
print('img2:',img2.size)
'''
img1: (500, 330)
img2: (250, 165)
'''

（4）粘贴和裁剪

①粘贴:

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

im:源图或像素值；box:粘贴区域；mask:遮罩

box：

a.（x1,y1）:将图像左上角对齐（x1,y1）,超出被粘贴图像区域丢弃

b.（x1,y1,x2,y2）:原图像与此区域保持一致。

c.   None：原图像与被粘贴图像必须大小一致。

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
img2=img1.copy()
#将每个像素值缩小一半
img2.thumbnail((img1.size[0]/3,img1.size[1]/3))
#把img2贴到img1上
img1.paste(img2,(30,40))
img1.show()

 结果：

 

（5）图像的旋转

Image.rotate(angle,resample=0,expand=0,center=None,translate=None,fillcolor=None)

angle：旋转角度

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
img1=img1.rotate(60)
img1.show()

（6）格式转换

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
#上下滤镜
#img2=img1.transpose(Image.FLIP_TOP_BOTTOM)#上下
img2=img1.transpose(Image.FLIP_LEFT_RIGHT)#左右
img2=img1.transpose(Image.ROTATE_90)#旋转90度，尺寸也变
img2=img1.transpose(Image.ROTATE_180)#旋转180度
img2.show()

（7）图像分离（split），混合（merge）

#导入模块
from PIL import Image
#打开图片
img1=Image.open('kiki.jpg')
img2=Image.open('yoki.jpg').resize(img1.size)
#分离
r1,g1,b1=img1.split()
r2,g2,b2=img2.split()
tempa=[r1,g2,b1]
tempb=[r2,g1,b2]
#混合
imga=Image.merge('RGB',tempa)
imgb=Image.merge('RGB',tempb)
imga.show()
imgb.show()

（7）图像滤镜

BLUR：模糊滤波

CONTOUR：轮廓滤波

DETAIL：细节滤波

EDGE_ENHANCE：边界增强滤波

EDGE_ENHANCE_MORE：边界增强滤波（程度更深）

EMBOSS：浮雕滤波

FIND_EDGES：寻找边界滤波

SMOOTH：平滑滤波

SMOOTH_MORE：平滑滤波（程度更深）

SHARPEN：锐化滤波

GaussianBlur(radius=2)：高斯模糊

例：

#导入模块
from PIL import Image,ImageFilter
#打开图片
img1=Image.open('kiki.jpg')
img1.thumbnail((img1.size[0]/3,img1.size[1]/3))
w,h=img1.size
#输出图片
img_output=Image.new('RGB',(3*w,4*h))
#高斯模糊
img1_GaussianBlur=img1.filter(ImageFilter.GaussianBlur(radius=3))
#BLUR普通模糊
img1_BLUR=img1.filter(ImageFilter.BLUR)
#DETAIL细节滤波
img1_DETAIL=img1.filter(ImageFilter.DETAIL)
#EDGE_ENHANCE：边界增强滤波
img1_EDGE_ENHANCE=img1.filter(ImageFilter.EDGE_ENHANCE)
#EDGE_ENHANCE_MORE：边界增强滤波（程度更深）
img1_EDGE_ENHANCE_MORE=img1.filter(ImageFilter.EDGE_ENHANCE_MORE)
#EMBOSS浮雕
img1_EMBOSS=img1.filter(ImageFilter.EMBOSS)
#FIND_EDGES：寻找边界滤波
img1_FIND_EDGES=img1.filter(ImageFilter.FIND_EDGES)
#SMOOTH：平滑滤波
img1_SMOOTH=img1.filter(ImageFilter.SMOOTH)
#SMOOTH_MORE：平滑滤波（程度更深）
img1_SMOOTH_MORE=img1.filter(ImageFilter.SMOOTH_MORE)
#SHARPEN：锐化滤波
img1_SHARPEN=img1.filter(ImageFilter.SHARPEN)
#CONTOUR：轮廓滤波
img1_CONTOUR=img1.filter(ImageFilter.CONTOUR)
#拼接
img_output.paste(img1,(0,0))
img_output.paste(img1_GaussianBlur,(w,0))
img_output.paste(img1_BLUR,(2*w,0))
img_output.paste(img1_DETAIL,(0,h))
img_output.paste(img1_EDGE_ENHANCE,(w,h))
img_output.paste(img1_EDGE_ENHANCE_MORE,(2*w,h))
img_output.paste(img1_EMBOSS,(0,2*h))
img_output.paste(img1_FIND_EDGES,(w,2*h))
img_output.paste(img1_SMOOTH,(2*w,2*h))
img_output.paste(img1_SMOOTH_MORE,(0,3*h))
img_output.paste(img1_SHARPEN,(w,3*h))
img_output.paste(img1_CONTOUR,(2*w,3*h))
img_output.show()

结果：

不想学了，我去打游戏了，过两天继续

继续继续

（8）图像整体运算

from PIL import ImageEnhance,Image
 
im1=Image.open('kiki.jpg')
out=im1.point(lambda i:i*2)#图片整体变亮
out.show()

 

 

B.ImageChops模块

（1）图片相加

ImageChops.add(im1,im2,scale=1.0,offset=0)

计算公式：

out=((im1+im2)/scale+offset)

from PIL import ImageChops,Image
 
im1=Image.open('kiki.jpg')
im2=Image.open('niki.jpg')
 
out=ImageChops.add(im1,im2,1,0)
out.show()

（2）图片相减

ImageChops.subtract(im1,im2,scale=1.0,offset=0)

计算公式：

out=((im1-im2)/scale+offset)

（3）图片变暗

ImageChops.darker(im1,im2)

比较两图片像素，取对应像素值的较小值然后保留，从而去除亮的部分

from PIL import ImageChops,Image
 
im1=Image.open('kiki.jpg')
im2=Image.open('niki.jpg')
 
out=ImageChops.darker(im1,im2)
out.show()

（4）图片变亮

ImageChops.lighter(im1,im2)

比较两图片像素，取对应像素值的较大值然后保留，从而去除暗的部分

from PIL import ImageChops,Image
 
im1=Image.open('kiki.jpg')
im2=Image.open('niki.jpg')
 
out=ImageChops.lighter(im1,im2)
out.show()

（5）屏幕函数

ImageChops.screen(im1,im2)

先反色后叠加，类似于将两张幻灯片用两台投影仪投影到一个屏幕上

计算公式：

out=MAX-((MAX-im1)*(MAX-im2)/MAX)

from PIL import ImageChops,Image
 
im1=Image.open('kiki.jpg')
im2=Image.open('niki.jpg')
 
out=ImageChops.screen(im1,im2)
out.show()

（6）反色函数

ImageChops.invert(im1)

计算公式：out=255-im1

from PIL import ImageChops,Image
 
im1=Image.open('kiki.jpg')
out=ImageChops.invert(im1)
out.show()

（7）比较函数

ImageChops.difference(im1,im2)

做减法操作取绝对值

计算公式：

abs(im1-im2)

from PIL import ImageChops,Image
 
im1=Image.open('kiki.jpg')
im2=Image.open('niki.jpg')
 
out=ImageChops.difference(im1,im2)
out.show()

B.ImageEnhance模块(图像增强)

使用方法：

image_enhance=ImageEnhance.XXX(img)（获取XXX调整器）

im=image_enhance.enhance(0~2)   0~1减弱，1~2增强

（1）获取色彩调整器

ImageEnhance.Color(im)

（2）获取对比度调整器

ImageEnhance.Contrast(im)

（3）获取亮度调整器

ImageEnhance.Brightness(im)

（4）获取清晰度调整器

ImageEnhancd.Sharpness(im)

from PIL import ImageEnhance,Image
 
im1=Image.open('kiki.jpg')
im1.thumbnail((im1.size[0]/3,im1.size[1]/3))
w,h=im1.size
out=Image.new('RGB',(3*w,4*h))
#获取色彩调整器对象
im_color=ImageEnhance.Color(im1)
im_color_a=im_color.enhance(1.5)
im_color_b=im_color.enhance(0.5)
 
#获取对比度调整器对象
im_contrast=ImageEnhance.Contrast(im1)
im_contrast_a=im_contrast.enhance(1.5)
im_contrast_b=im_contrast.enhance(0.5)
 
#获取亮度调整器对象
im_brightness=ImageEnhance.Brightness(im1)
im_brightness_a=im_brightness.enhance(1.5)
im_brightness_b=im_brightness.enhance(0.5)
 
#获取锐度调整器对象
im_sharpness=ImageEnhance.Sharpness(im1)
im_sharpness_a=im_sharpness.enhance(1.7)
im_sharpness_b=im_sharpness.enhance(0.2)
 
out.paste(im1,(0,0))
out.paste(im_color_a,(w,0))
out.paste(im_color_b,(2*w,0))
 
out.paste(im1,(0,h))
out.paste(im_contrast_a,(w,h))
out.paste(im_contrast_b,(2*w,h))
 
out.paste(im1,(0,2*h))
out.paste(im_brightness_a,(w,2*h))
out.paste(im_brightness_b,(2*w,2*h))
 
out.paste(im1,(0,3*h))
out.paste(im_sharpness_a,(w,3*h))
out.paste(im_sharpness_b,(2*w,3*h))
 
out.show()

 

C.ImagDraw模块(图像绘制)

使用方法：

drawObject = ImageDraw.Draw(blank)

功能：绘制二维图像

from PIL import Image, ImageDraw

img = Image.new('RGBA', (200, 200), 'white')
idraw = ImageDraw.Draw(img)

idraw.rectangle((10, 10, 100, 100), fill='blue')

img.save('D:\\\\rectangle.png')

D.ImagFont模块

功能：验证码功能

# -*- coding: utf-8 -*-
# __author__: Pad0y

from PIL import Image, ImageDraw, ImageFont
from random import choice, randint, randrange
import string

# 候选字符集,大小写字母+数字
chrs = string.ascii_letters + string.digits


def selected_chrs(length):
    """
    返回length个随机字符串
    :param length:
    :return:
    """
    result = ''.join(choice(chrs) for _ in range(length))
    return result


def get_color():
    """
    设置随机颜色
    :return:
    """
    r = randint(0, 255)
    g = randint(0, 255)
    b = randint(0, 255)
    return (r, g, b)


def main(size=(200, 100), chrNumber=6, bgcolor=(255, 255, 255)):
    """
    定义图片大小，验证码长度，背景颜色
    :param size:
    :param chrNumber:
    :param bgcolor:
    :return:
    """
    # 创建空白图像和绘图对象
    image_tmp = Image.new('RGB', size, bgcolor)
    draw = ImageDraw.Draw(image_tmp)

    # 生成并计算随机字符的宽度和高度
    text = selected_chrs(chrNumber)
    font = ImageFont.truetype('c:\\\\windows\\\\fonts\\\\simkai.ttf', 48)  # 选定一款系统字体
    width, height = draw.textsize(text, font)
    if width + 2*chrNumber > size[0] or height > size[1]:
        print('Size Error!')
        return

    # 绘制字符串
    startX = 0
    width_eachchr = width // chrNumber  # 计算每个字符宽度
    for i in range(chrNumber):
        startX += width_eachchr + 1
        position = (startX, (size[1]-height)//2+randint(-10, 10))  # 字符坐标, Y坐标上下浮动
        draw.text(xy=position, text=text[i], font=font, fill=get_color())  # 绘制函数

    # 对像素位置进行微调，实现验证码扭曲效果
    img_final = Image.new('RGB', size, bgcolor)
    pixels_final = img_final.load()
    pixels_tmp = image_tmp.load()
    for y in range(size[1]):
        offset = randint(-1, 0)  # randint()相当于闭区间[x,y]
        for x in range(size[0]):
            newx = x + offset  # 像素微调
            if newx >= size[0]:
                newx = size[0] - 1
            elif newx < 0:
                newx = 0
            pixels_final[newx, y] = pixels_tmp[x, y]

    # 绘制随机颜色随机位置的干扰像素
    draw = ImageDraw.Draw(img_final)
    for i in range(int(size[0]*size[1]*0.07)):  # 7%密度的干扰像素
        draw.point((randrange(size[0]), randrange(size[1])), fill=get_color())  # randrange取值范围是左开右闭

    # 绘制随机干扰线，这里设置为8条
    for i in range(8):
        start = (0, randrange(size[1]))
        end = (size[0], randrange(size[1]))
        draw.line([start, end], fill=get_color(), width=1)

    # 绘制随机弧线
    for i in range(8):
        start = (-50, -50)  # 起始位置在外边看起来才会像弧线
        end = (size[0]+10, randint(0, size[1]+10))
        draw.arc(start+end, 0, 360, fill=get_color())

    # 保存图片
    img_final.save('Veri_code.jpg')
    img_final.show()


if __name__ == '__main__':
    main((200, 100), 6, (255, 255, 255))