目录

1、导入库文件

2、设计GUI

3、调用摄像头

4、实时图像处理

4.1、阈值二值化

4.2、边缘检测

4.3、轮廓检测

4.4、高斯滤波

4.5、色彩转换

4.6、调节对比度

5、退出系统

初学OpenCV图像处理的小伙伴肯定对什么高斯函数、滤波处理、阈值二值化等特性非常头疼，这里给各位分享一个小项目，可通过摄像头实时动态查看各类图像处理的特点，也可对各位调参、测试有一定帮助。

1、导入库文件

这里主要使用PySimpleGUI、cv2和numpy库文件，PySimpleGUI库文件实现GUI可视化，cv2库文件是Python的OpenCV接口文件，numpy库文件实现数值的转换和运算，均可通过pip导入。

import PySimpleGUI as sg  #pip install pysimplegui
import cv2  #pip install opencv-python
import numpy as np #pip install numpy

2、设计GUI

基于PySimpleGUI库文件实现GUI设计，本项目界面设计较为简单，设计800X400尺寸大小的框图，浅绿色背景，主要由摄像头界面区域和控制按钮区域两部分组成。效果如下所示：



GUI代码如下所示：

    #背景色
    sg.theme('LightGreen')

    #定义窗口布局
    layout = [
      [sg.Image(filename='', key='image')],
      [sg.Radio('None', 'Radio', True, size=(10, 1))],
      [sg.Radio('threshold', 'Radio', size=(10, 1), key='thresh'),
       sg.Slider((0, 255), 128, 1, orientation='h', size=(40, 15), key='thresh_slider')],
      [sg.Radio('canny', 'Radio', size=(10, 1), key='canny'),
       sg.Slider((0, 255), 128, 1, orientation='h', size=(20, 15), key='canny_slider_a'),
       sg.Slider((0, 255), 128, 1, orientation='h', size=(20, 15), key='canny_slider_b')],
      [sg.Radio('contour', 'Radio', size=(10, 1), key='contour'),
       sg.Slider((0, 255), 128, 1, orientation='h', size=(20, 15), key='contour_slider'),
       sg.Slider((0, 255), 80, 1, orientation='h', size=(20, 15), key='base_slider')],
      [sg.Radio('blur', 'Radio', size=(10, 1), key='blur'),
       sg.Slider((1, 11), 1, 1, orientation='h', size=(40, 15), key='blur_slider')],
      [sg.Radio('hue', 'Radio', size=(10, 1), key='hue'),
       sg.Slider((0, 225), 0, 1, orientation='h', size=(40, 15), key='hue_slider')],
      [sg.Radio('enhance', 'Radio', size=(10, 1), key='enhance'),
       sg.Slider((1, 255), 128, 1, orientation='h', size=(40, 15), key='enhance_slider')],
      [sg.Button('Exit', size=(10, 1))]
    ]

    #窗口设计
    window = sg.Window('OpenCV实时图像处理',
               layout,
               location=(800, 400),
               finalize=True)

3、调用摄像头

打开电脑内置摄像头，将数据显示在GUI界面上，效果如下所示：



代码如下所示：

    #打开内置摄像头
    cap = cv2.VideoCapture(0)
    while True:
        event, values = window.read(timeout=0, timeout_key='timeout')

        #实时读取图像
        ret, frame = cap.read()

        #GUI实时更新
        imgbytes = cv2.imencode('.png', frame)[1].tobytes()
        window['image'].update(data=imgbytes)

    window.close()

4、实时图像处理

4.1、阈值二值化

进行阈值二值化操作，大于阈值values['thresh_slider']的，使用255表示，小于阈值values['thresh_slider']的，使用0表示，效果如下所示：



 代码如下所示：

if values['thresh']:
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)[:, :, 0]
    frame = cv2.threshold(frame, values['thresh_slider'], 255, cv2.THRESH_BINARY)[1]

4.2、边缘检测

进行边缘检测，values['canny_slider_a']表示最小阈值，values['canny_slider_b']表示最大阈值，效果如下所示：



代码如下所示：

if values['canny']:
    frame = cv2.Canny(frame, values['canny_slider_a'], values['canny_slider_b'])

4.3、轮廓检测

轮廓检测是形状分析和物体检测和识别的有用工具，连接所有连续点（沿着边界）的曲线，具有相同的颜色或强度，效果如下所示：



 代码如下所示：

if values['contour']:
    hue = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    hue = cv2.GaussianBlur(hue, (21, 21), 1)
    hue = cv2.inRange(hue, np.array([values['contour_slider'], values['base_slider'], 40]),
                      np.array([values['contour_slider'] + 30, 255, 220]))
    cnts= cv2.findContours(hue, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0]
    cv2.drawContours(frame, cnts, -1, (0, 0, 255), 2)


4.4、高斯滤波

进行高斯滤波,(21, 21)表示高斯矩阵的长与宽都是21，标准差取values['blur_slider']，效果如下所示：



 代码如下所示：

if values['blur']:
    frame = cv2.GaussianBlur(frame, (21, 21), values['blur_slider'])


4.5、色彩转换

色彩空间的转化，HSV转换为BGR，效果如下所示：



 代码如下所示：

if values['hue']:
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    frame[:, :, 0] += int(values['hue_slider'])
    frame = cv2.cvtColor(frame, cv2.COLOR_HSV2BGR)

4.6、调节对比度

增强对比度，使图像中的细节看起来更加清晰，效果如下所示：



  代码如下所示：

if values['enhance']:
    enh_val = values['enhance_slider'] / 40
    clahe = cv2.createCLAHE(clipLimit=enh_val, tileGridSize=(8, 8))
    lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
    lab[:, :, 0] = clahe.apply(lab[:, :, 0])
    frame = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)


5、退出系统

直接break即可跳出循环。

if event == 'Exit' or event is None:
    break

拓展学习：基于Python的人工智能美颜系统 

请关注公众号，回复关键字：OpenCV实时图像处理，获取项目资源。

文章目录
Pillow模块讲解
一、Image模块
1.1 、打开图片和显示图片
1.2、创建一个简单的图像
1.3、图像混合
（1）透明度混合
（2）遮罩混合
1.4、图像缩放
（1）按像素缩放
（2）按尺寸缩放
1.5、图像的剪切与粘贴
（1）图像粘贴
（2）裁剪图像
1.4、图像旋转和格式转换
（1）图像旋转
（2）格式转换
1.5、分离和合并
（1）分离
（2）合并
二、ImageFilter
2.1、高斯模糊
2.2、其它滤镜
三、ImageChops模块（图像合成）
3.1、加法运算
3.2、减法运算
3.3、其它函数
四、ImageEnhance模块（色彩、亮度）
五、ImageDraw模块
5.1、绘制简单形状
（1）绘制直线
（2）绘制矩形
（3）绘制圆弧
（4）绘制椭圆
（5）绘制弦
（6）绘制扇形
（7）绘制多边形
（8）绘制点
5.2、绘制文字

Pillow模块讲解
一、Image模块
1.1 、打开图片和显示图片
对图片的处理最基础的操作就是打开这张图片，我们可以使用Image模块中的open(fp, mode)方法，来打开图片。open方法接收两个参数，第一个是文件路径，第二个是模式。主要的模式如下：




mode（模式）
bands（通道）
说明




“1”
1
数字1，表示黑白二值图片，每个像素用0或1共1位二进制码表示


“L”
1
灰度图


“P”
1
索引图


“RGB”
3
24位真彩图


“RGBA”
4
“RGB”+透明通道


“CMYK”
4
印刷模式图像


光理论是不够的,在此送大家一套2020最新Python全栈项目视频教程，点击此处 进来获取  跟着练习下，希望大家一起进步哦！

更多的模式也就不说了，关于模式的模式的详细介绍我也不知道。这个open方法返回一个Image对象，mode也不是必须参数。打开图片代码如下：
from PIL import Image
# 打开图片
im = Image.open('test.jpg')
# 显示图片
im.show()

当然显示图片不是我们的重点，我们获取Image对象之后，就可以获取它的一些信息了。
print('图像的格式：', im.format)
print('图像的大小：', im.size)
print('图像的宽度：', im.width)
print('图像的高度：', im.height)
# 传入坐标的元组
print('获取某个像素点的颜色值：', im.getpixel(100, 100))

在我的环境中运行结果如下：
图像的格式： JPEG
图像的大小： (3968, 2976)
图像的宽度： 3968
图像的高度： 2976
获取某个像素点的颜色值： (198, 180, 132)

1.2、创建一个简单的图像
在Image模块中，提供了创建图像的方法。主要是通过**Image.new(mode, size, color)**实现，该方法传入三个参数：

mode：图像的创建模式
size：图像的大小
color：图像的颜色

用该方法可以创建一个简单的图像，之后我们可以通过save方法将图像保存：
from PIL import Image
# 创建一个简单的图像
im = Image.new('RGB', (100, 100), 'red')
# 保存这个图像
im.save('red.png')

生成图片如下：

1.3、图像混合
（1）透明度混合
透明度混合主要是使用**Image中的blend(im1, im2, alpha)**方法，对该方法的解释如下：

im1：Image对象，在混合的过程中，透明度设置为（1-apha）
im2：Image对象，在混合的过程中，透明度设置为（apha）
alpha：透明度，取值是0-1。当透明度为0是，显示im1对象；当透明度为1时，显示im2对象


注意：im1和im2的大小必须一样，且mode都为RGB

代码实现如下：
from PIL import Image

# 打开im1
im1 = Image.open('pic.jpg').convert(mode='RGB')
# 创建一个和im1大小一样的图像
im2 = Image.new('RGB', im1.size, 'red')
# 混合图片，并显示
Image.blend(im1, im2, 0.5).show()

下面为原图和混合图的对比：

不得不说，我家艾斯真滴帅。
（2）遮罩混合
接下来就是很迷的时刻了，我们可以通过Image.composite(im1, im2, mask)方法实现遮罩混合。三个参数都是Image对象，该方法的作用就是使用mask来混合im1和im2。我是听不懂，你们能听懂最好给我讲一下。具体实现如下：
# 这句代码写了好多遍，我真不想写了
from PIL import Image
# 打开图像1
im1 = Image.open('pic1.jpg')
# 打开图像2
im2 = Image.open('pic2.jpg')
# 重新设置im2的大小
im2.resize(im1.size)
# 将图像2的三个色道分离，其中r、g、b都为Image对象
r, g, b = im2.split()
# 遮罩混合
Image.composite(im1, im2, b).show()


注意：im1、im2和mask的大小必须一样

im1、im2和遮罩混合效果对比如下：

依旧是我帅气的艾斯。
1.4、图像缩放
（1）按像素缩放
按像素缩放通过Image.eval(im1, fun)方法实现，其中im1为我们老生常谈的Image对象了；第二个为一个方法（函数），该函数传入一个参数，即像素点。该函数会对图片中每个像素点进行函数内的操作。下面我们对来简单使用一下这个方法：
from PIL import Image
# 打开一张图像
im = Image.open('抠鼻屎.jpg')
# 对该图像每个像素点进行*2处理
Image.eval(im, lambda x:x*2).show()

这里我使用的lambda表达式，当然一般也都是用lambda表达式，不过你也可以像下面这样写：
# 定义一个方法
def func(x):
    return x*2
# 对图像im每个像素点进行func中的操作，其中func不能加()
Image.eval(im, func)

效果图如下：

细心的读者应该可以发现，这个抠鼻屎的图片和笔者头像并不完全一样。在血色方面，笔者的头像确实要差几分。

注意：笔者在日常生活中可不是天天在大街上抠鼻屎的那种。

（2）按尺寸缩放
按尺寸缩放是通过Image对象的thumbnail()方法实现的，这里不同于前面直接通过Image调用方法，而是使用Image的具体实例im2调用thumbnail方法，从而对im2直接进行处理。具体代码如下：
from PIL import Image
# 打开图像
im1 = Image.open('xx.jpg')
# 复制图像
im2 = im1.copy()
# 将复制后的图像进行缩放，传入一个元组
im2.thumbnail((100, 100))
# 输出图像大小
print("im1的大小", im1.size)
print('im2的大小', im2.size)

这里缩放图像并不会对图像进行变形，即显示效果是一样的。这里就不放效果图了，输入结果如下：
im1的大小 (960, 960)
im2的大小 (100, 100)

1.5、图像的剪切与粘贴
（1）图像粘贴
粘贴的实现主要是通过Image对象的paste(im, box, mask)方法，其中im为Image对象；box为要粘贴到的区域；mask为遮罩（我也不知道啥是遮罩）。其中box的参数有三种形式：

(x1, y1)：将im左上角对齐(x1,y1)点，其余部分粘贴，超出部分抛弃
(x1, x2, y1, y2)：将im粘贴至此区域
None：此时im必须与源图像大小一致

（2）裁剪图像
裁剪主要通过Image对象的crop(box)方法实现，box同粘贴中一致。
接下来我们做一个小练习，想将图像某个区域剪切下来，然后粘贴到另一个图像上：
from PIL import Image
# 打开图像
im = Image.open('nnz.jpg')
# 复制两份
im1 = im.copy()
im2 = im.copy()
# 剪切图片
im_crop = im1.crop((200, 200, 400, 400))
# 粘贴图片
im2.paste(im_crop, (30, 30))
im2.show()

原图和效果图对比如下：

貌美如花的娜娜子。
1.4、图像旋转和格式转换
（1）图像旋转
图像旋转就非常简单了，简单的一句代码，通过Image对象调用rotate()，该方法返回被旋转图像的一个副本：
from PIL import Image
im = Image.open('nnz.jpg')
# 旋转90度然后显示
im.rotate(90).show()

顺时针逆时针就不要问我了。
（2）格式转换

convert：转换图像的模式
transpose：转换图像的格式

convert之前已经使用过了，这里就简单演示一下transpose的作用，transpose主要传入一些Image中的常量：
from PIL import Image
# 打开图像
im = Image.open('nnz.jpg')
# 这里我也不知道注释啥了，总之效果和rotate(90)效果一样
im.transpose(Image.ROTATE_90).show()

效果图我也就不放了，给大家列出一些可以传入的常量和该常量的作用：




常量
作用




Image.FILP_TOP_BOTTOM
上下翻转


Image.FILP_LEFT_RIGHT
左右翻转


Image.ROTATE_90
翻转90°


Image.ROTATE_180
翻转180°


Image.TRANSPOSE
颠倒


我也不知道这是哪门子的格式转换。
1.5、分离和合并
（1）分离
这个是之前使用过的，通过Image对象的split()方法，将图像的RGB三个通道分离，并返回三个Image对象：
from PIL import Image
# 打开图像
im = Image.open('nnz.jpg')
# 分离通道，返回3个Image对象
r, g, b = im.split()

三个通道的效果图如下：

（2）合并
合并是通过Image.merge(mode, bands)方法实现的，其中mode为模式，bands为通道列表，传入一个列表类型数据。下面我实现以下小新多年来的愿望：
from PIL import Image
# 打开小新.jpg和娜娜子.jpg
im1 = Image.open('娜娜子.jpg')
im2 = Image.open('小新.jpg')
# 让im2大小和im1一样
im2.resize(im1.size)
# 将两个图像分别分离
r1, g1, b1 = im1.split()
r2, g2, b2 = im2.split()
# 合并图像
im3 = Image.merge('RGB', [r1, g2, b1])
im3.show()

效果图如下，看到这么美的图片，小新一定会感谢我的：

到这里，我们就把Image模块的大致内容讲解完了，接下来我们来了解PIL中更丰富的功能。
二、ImageFilter
ImageFilter中提供了很多常用的滤镜功能，
2.1、高斯模糊
高斯模糊也叫高斯平滑，是啥我也不知道，反正听名字就是模糊。我们结合上面的内容完成一个小案例：
from PIL import Image, ImageFilter
# 打开图像
im1 = Image.open('iron_man.jpg')
# 创建一个im1两倍宽的图像
img = Image.new('RGB', (im1.width*2, im1.height), 'red')
# 高斯模糊处理
im2 = im1.filter(ImageFilter.GaussianBlur)
# 将im1粘贴到img上
img.paste(im1, (0, 0))
# 将im2（高斯模糊后的图像）粘贴到img上
img.paste(im2, (im1.width, 0))
img.show()

为了考虑小新的感受，下面不再用娜娜子作为素材。我选取了一张钢铁侠的图片，运行结果如下：

希望各位读者不要误会，他俩真没说你帅，他俩只说笔者一个人帅。
2.2、其它滤镜
除了高斯模糊，ImageFilter中还提供了许多其它滤镜：




滤镜值
滤镜名词




BLUR
模糊效果


CONTOUR
轮廓


DETAIL
细节


EDGE_ENHANCE
边缘增强


EDGE_ENHANCE_MORE
边缘增强plus


EMBOSS
浮雕效果


FIND_EDGES
寻找边缘


SMOOTH
平滑


笔者用一张美女图片，测试了上面几个滤镜的效果，发现9张图是看起来是完全一样的。虽然完全一样，但是笔者还是打算将这次测试的结果作为我慈善事业的一部分，分享给各位读者。

其中1为高斯模糊，2-9分别为表格中的8个滤镜。
三、ImageChops模块（图像合成）
ImageChops模块中，提供了很多图像合成的方法。这些方法是通过计算通道中像素值来实现的，不同的方法有不同的计算方式。
3.1、加法运算
加法运算通过**ImageChops.add(image1, image2, scale=1.0, offset=0)**方法实现，合成公式如下：
out = (im1 + im2)/scale + offset

我也看不懂，其中scale和offset是有默认值的。所以使用时我们可以省略参数，具体实现如下：
from PIL import Image, ImageChops
# 打开图像
im1 = Image.open('im1.jpg')
im2 = Image.open('im2.jpg')
# 合成图像并显示
im3 = ImageChops.add(im1, im2)
im3.show()

实验结果产不忍赌，效果图如下：

3.2、减法运算
加法运算通过**ImageChops.subtract(image1, image2, scale=1.0, offset=0)**方法实现，合成公式如下：
out = (im1 - im2)/scale + offset

其使用和add方法是一致的，代码如下：
from PIL import Image, ImageChops
# 打开图像
im1 = Image.open('xscn.jpg')
im2 = Image.open('xscn2.jpg')
# 合成图像并显示
im3 = ImageChops.subtract(im1, im2)
im3.show()

原本是不想放效果图的，但是运行后，发现效果图比较美，所以想和大家分享一下：

希望大家读到这篇博客的时候是独自一人的深夜。
3.3、其它函数
因为大多数函数的使用都比较简单，所以后续的函数也不单独拿出来讲了，具体功效可以看下列表：




函数名
参数
作用
计算公式




darker(变暗)
(image1, image2)
对比两种图片的像素，取两种图片中对应像素的较小值。（去亮留暗）
min(im1, im2)


lighter（变亮）
同上
对比两种图片的像素，取两种图片中对应像素的较大值。（去暗留亮）
max(im1, im2)


invert（反色）
(image)
将max(255)减去每个像素的值
max-image


multiply（叠加）
(image1, image2)
两种图片互相叠加。如果和黑色叠加，将获得一张很色图片
im1*im2/max


screen（屏幕）
同上
先反色后叠加
max-((max-im1)*(max-im2)/max)


difference（比较）
同上
各个像素做减法，取绝对值。如果像素相同结果为黑色
abs(im1-im2)


演示代码如下：
from PIL import Image, ImageChops

# 打开图像
im1 = Image.open("im1.jpg")
im2 = Image.open("im2.jpg")

# 对图像进行各种操作
im3 = ImageChops.darker(im1, im2)
im3.save('darker.jpg')
im3 = ImageChops.lighter(im1, im2)
im3.save('lighter.jpg')
im3 = ImageChops.invert(im1)
im3.save('invert.jpg')
im3 = ImageChops.multiply(im1, im2)
im3.save('multiply.jpg')
im3 = ImageChops.screen(im1, im2)
im3.save('screen.jpg')
im3 = ImageChops.difference(im1, im2)
im3.save('difference.jpg')

其中，我选取的素材im1和im2都是上面使用到的那两张，效果图如下：

这样，我的女神就被我毁的体无完肤了。
四、ImageEnhance模块（色彩、亮度）
ImageEnhance提供了许多函数，用于调整图像的色彩、对比度、亮度、清晰度等。调整图像的步骤如下：

确定要调整的参数，获取特定的调整器
调用调整器的enhance方法，传入参数进行调整。


注意：所有调整器都实现同一个接口，该接口中包含一个方法enhance

其中enhance方法接收一个参数factor，factor是一个大于0的数。当factor为1时，返回原图，当factor小于1返回减弱图，大于1返回增强图。
各个获取色彩调整器的方法如下：




方法名称
方法作用




ImageEnhance.Color()
获取颜色调整器


ImageEnhance.Contrast()
获取对比度调整器


ImageEnhance.Brightness()
获取亮度调整器


ImageEnhance.Sharpness()
获取清晰度调整器


虽然是很想偷懒，不去做实验，但是想想还是做了如下实验，代码如下：
from PIL import Image, ImageEnhance
# 打开im1
im1 = Image.open("gtx.jpg")
# 获取颜色（各种）调整器
enhance_im1 = ImageEnhance.Color(im1)
#enhance_im1 = ImageEnhance.Contrast(im1)
#enhance_im1 = ImageEnhance.Brightness(im1)
#enhance_im1 = ImageEnhance.Sharpness(im1)
# 减弱颜色（以及其它属性）
im2 = enhance_im1.enhance(0.5)
# 增强颜色（以及其它属性）
im3 = enhance_im1.enhance(1.5)

# 获取原图大小
w, h = im1.size
# 创建一个原图大小3倍的图片
img = Image.new("RGB", (w*3, h))
# 将减弱的图片放在最左边
img.paste(im2, (0, 0))
# 将原图放在中间
img.paste(im1, (w, 0))
# 将增强后的图片放在最右边
img.paste(im3, (w*2, 0))
# 显示图片
img.show()

其中，我们只需要修改获取调整器的代码就可以了，获取其它调制器的代码我注释了。然后看看效果图：

这种不伤大雅的工作，让我唐尼叔做再适合不过了。
另外再讲一个调节亮度的函数，但是这个函数时Image中的函数point()，而不是ImageEnhance的。该函数传入一个参数，使用方法和Image.eval()类似，使用示例如下：
from PIL import Image
# 打开图像
im1 = Image.open('gtx.jpg')

# 变暗操作
im2 = im1.point(lambda x:x*0.5)
# 变量操作
im3 = im1.point(lambda x:x*1.5)
# 获取原图大小
w, h = im1.size
# 创建一个原图大小3倍的图片
img = Image.new("RGB", (w*3, h))
# 将减弱的图片放在最左边
img.paste(im2, (0, 0))
# 将原图放在中间
img.paste(im1, (w, 0))
# 将增强后的图片放在最右边
img.paste(im3, (w*2, 0))
# 显示图片
img.show()

效果图如下：

五、ImageDraw模块
该模块提供了许多绘制2D图像的功能，我们可以通过绘制获取一个全新的图像，也可以在原有的图像上进行绘制。在我们使用该模块进行绘制时，我们需要先获取ImageDraw.Draw对象，获取方式如下：
from PIL import ImageDraw
# 构造函数中，im为一个Image对象
drawer = ImageDraw.Draw(im)

我们获取ImageDraw.Draw对象后就可以进行相应的绘制了。
5.1、绘制简单形状
在绘制之前，我们先创建一个空白的图片：
from PIL import Image, ImageDraw

# 创建一个300*300的白色图片
im = Image.new("RGB", (300, 300), "white")
# 获取ImageDraw.Draw对象
drawer = ImageDraw.Draw(im)

后续的绘制都可以使用对象drawer绘制。
（1）绘制直线
"""
xy：起点坐标和终点坐标(x1, y1, x2, y2)
fill：填充色。"red"、"blue"...
width：轮廓粗细
joint：连接方式，可以是曲线
"""
line(xy, fill, width, joint)
# 绘制直线
drawer.line((50, 50, 150, 150), fill='green',width=2)

（2）绘制矩形
"""
xy：左上角坐标和右下角坐标(x1, y1, x2, y2)
fill：填充色。"red"、"blue"...
outline：轮廓色。同上
width：轮廓粗细
"""
rectangle(xy, fill, outline, width)
# 使用示例
drawer.rectangle((50, 50, 150, 150), fill='green', outline='red', width=3)

（3）绘制圆弧
"""
xy：包含圆弧所在圆的矩形的左上角坐标和右下角坐标(x1, y1, x2, y2)
start：起始角度
end：终止角度
fill：填充色。"red"、"blue"...
width：轮廓粗细
"""
arc(xy, start, end, fill, width)
# 使用示例
drawer.arc((50, 50, 150, 150), start=0, end=90, fill='green', width=3)

对于xy参数的解释如图所示：

（4）绘制椭圆
"""
xy：包含椭圆（或圆）的矩形的左上角坐标和右下角坐标(x1, y1, x2, y2)
fill：填充色。"red"、"blue"...
outline：轮廓颜色
width：轮廓粗细
"""
ellipse(xy, fill, outline, width)
# 使用示例
drawer.ellipse((50, 50, 150, 150),fill='green', outline='red', width=3)

（5）绘制弦

"""
xy：弦所在椭圆的矩形的左上角坐标和右下角坐标(x1, y1, x2, y2)
start：开始角度
end：终点角度
fill：填充色。"red"、"blue"...
outline：轮廓颜色
width：轮廓粗细
"""
chord(xy, start, end, fill, outline, width)
# 使用示例
drawer.chord((50, 50, 150, 150),start=0, end=90, fill='green', outline='red', width=3)

（6）绘制扇形

"""
xy：扇形所在椭圆的矩形的左上角坐标和右下角坐标(x1, y1, x2, y2)
start：开始角度
end：终点角度
fill：填充色。"red"、"blue"...
outline：轮廓颜色
width：轮廓粗细
"""
pieslice(xy, start, end, fill, outline, width)
# 使用示例
drawer.pieslice((50, 50, 150, 150),start=0, end=90, fill='green', outline='red', width=3)

（7）绘制多边形
"""
xy：多边形各个点坐标的元组/列表(x1, y1, x2, y2)
fill：填充色。"red"、"blue"...
outline：轮廓颜色
"""
pieslice(xy, fill, outline)
# 使用示例
drawer.polygon((50, 50, 150, 150, 150, 200, 200, 250, 50, 50), fill='green', outline='red')

（8）绘制点
"""
xy：点的坐标
fill：填充色。"red"、"blue"...
"""
point(xy, fill)
# 使用示例
drawer.point((100, 100), fill='black')

除了上面这些简单图形外，我们还可以使用Draw绘制文字。
5.2、绘制文字
绘制文字和绘制图形是一样的：
"""
xy：起点坐标
text：绘制的文本
fill：填充色。"red"、"blue"...
...其中绘制文字还有许多其它参数
"""
text(xy, text, fill)
# 使用示例
drawer.text((100, 100), text='zack' fill='red')

当我们绘制中文时，上述代码会报错，因为默认编码是不支持中文的。我们可以在C:/Windows/Fonts目录下找到字体文件，我们选择一个支持中文的。我这里直接是将字体文件复制到项目底下来了，代码如下：
from PIL import Image, ImageDraw, ImageFont
# 创建一个图像用于绘制文字
im = Image.new("RGB", (300, 300), "white")
drawer = ImageDraw.Draw(im)
# 获取字体对象
imFont = ImageFont.truetype('simkai.ttf', 30)
# 绘制文字时设置字体
drawer.text((50, 100),text="啥",font=imFont,fill="red")
im.show()

最后送大家一套2020最新Pyhon项目实战视频教程，点击此处 进来获取  跟着练习下，希望大家一起进步哦！
我们使用了ImageFont.truetype()函数获取字体对象，在获取时我们可以设置字体大小。到此我们就了解了PIL的各种操作了，感兴趣的读者可以关注我的个人公众号：ZackSock。

用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，可以兼顾执行性能和开发效率。

该系列文章是讲解Python OpenCV图像处理知识，前期主要讲解图像入门、OpenCV基础用法，中期讲解图像处理的各种算法，包括图像锐化算子、图像增强技术、图像分割等，后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助，如果有不足之处，还请海涵~
该系列在github所有源代码：https://github.com/eastmountyxz/ImageProcessing-Python

PS：请求帮忙点个Star，哈哈，第一次使用Github，以后会分享更多代码，一起加油。
同时推荐作者的C++图像系列知识：

[数字图像处理] 一.MFC详解显示BMP格式图片

[数字图像处理] 二.MFC单文档分割窗口显示图片

[数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解

[数字图像处理] 四.MFC对话框绘制灰度直方图

[数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解

[数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解

[数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解
本篇文章作为第一篇，将讲解图像处理基础知识和OpenCV入门函数，知识点如下：

1.图像基础知识

2.OpenCV读写图像

3.OpenCV像素处理
PS: 文章也学习了网易云高登教育的知识，推荐大家学习。
PSS：2019年1~2月作者参加了CSDN2018年博客评选，希望您能投出宝贵的一票。我是59号，Eastmount，杨秀璋。投票地址：https://bss.csdn.net/m/topic/blog_star2018/index

	

五年来写了314篇博客，12个专栏，是真的热爱分享，热爱CSDN这个平台，也想帮助更多的人，专栏包括Python、数据挖掘、网络爬虫、图像处理、C#、Android等。现在也当了两年老师，更是觉得有义务教好每一个学生，让贵州学子好好写点代码，学点技术，"师者，传到授业解惑也"，提前祝大家新年快乐。2019我们携手共进，为爱而生。



一.图像基础知识
图像都是由像素(pixel)构成的，即图像中的小方格，这些小方格都有一个明确的位置和被分配的色彩数值，而这些一小方格的颜色和位置就决定该图像所呈现出来的样子。像素是图像中的最小单位，每一个点阵图像包含了一定量的像素，这些像素决定图像在屏幕上所呈现的大小。



图像通常包括二值图像、灰度图像和彩色图像。



1.二值图像

二值图像中任何一个点非黑即白，要么为白色（像素为255），要么为黑色（像素为0）。将灰度图像转换为二值图像的过程，常通过依次遍历判断实现，如果像素>=127则设置为255，否则设置为0。



2.灰度图像

灰度图像除了黑和白，还有灰色，它把灰度划分为256个不同的颜色，图像看着也更为清晰。将彩色图像转换为灰度图是图像处理的最基本预处理操作，通常包括下面几种方法：

(1) 浮点算法：Gray=R0.3+G0.59+B0.11

(2) 整数方法：Gray=(R30+G59+B11)/100

(3) 移位方法：Gray=(R28+G151+B77)>>8;

(4) 平均值法：Gray=（R+G+B）/3;(此程序采用算法)

(5) 仅取绿色：Gray=G；

(6) 加权平均值算法：根据光的亮度特性，公式:  R=G=B=R0.299+G*0.587+B0.144
通过上述任一种方法求得Gray后，将原来的RGB(R,G,B)中的R,G,B统一用Gray替换，形成新的颜色RGB(Gray,Gray,Gray)，用它替换原来的RGB(R,G,B)就是灰度图了。改变象素矩阵的RGB值，来达到彩色图转变为灰度图。



3.彩色图像

彩色图像是RGB图像，RGB表示红、绿、蓝三原色，计算机里所有颜色都是三原色不同比例组成的，即三色通道。






二.OpenCV读写图像
本文主要使用Python2.7和OpenCV进行讲解，首先调用"pip install opencv-python"安装OpenCV库，如下图所示：



1.读入图像

OpenCV读图像主要调用下面函数实现：

img = cv2.imread(文件名,[,参数])

参数(1) cv2.IMREAD_UNCHANGED  (图像不可变)

参数(2) cv2.IMREAD_GRAYSCALE (灰度图像)

参数(3) cv2.IMREAD_COLOR (读入彩色图像)

参数(4) cv2.COLOR_BGR2RGB (图像通道BGR转成RGB)

2.显示图像

显示图像调用函数如下：

cv2.imshow(窗口名, 图像名)

3.窗口等待

调用函数如下：

cv2.waitKey(delay)

键盘绑定函数，共一个参数，表示等待毫秒数，将等待特定的几毫秒，看键盘是否有输入，返回值为ASCII值。如果其参数为0，则表示无限期的等待键盘输入；参数>0表示等待delay毫秒；参数<0表示等待键盘单击。

4.删除所有窗口

调用函数如下：

cv2.destroyAllWindows() 删除所有窗口

cv2.destroyWindows() 删除指定的窗口

5.写入图片

调用函数如下：

retval = cv2.imwrite(文件地址, 文件名)

下面代码是读入图片并显示保存。
# -*- coding:utf-8 -*-
import cv2

#读取图片
img = cv2.imread("test.jpg")

#显示图像
cv2.imshow("Demo", img)

#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

#写入图像
cv2.imwrite("testyxz.jpg", img)

输出结果如下图所示，并且在文件夹下保存了一张名为“testyxz.jpg”的图像。



如果代码中没有watiKey(0)函数，则运行结果如下图所示：



同时

可以对代码进行升级，如下所示：
#无限期等待输入
k=cv2.waitKey(0)
#如果输入ESC退出
if k==27:
    cv2.destroyAllWindows()




三.OpenCV像素处理
1.读取像素

灰度图像直接返回灰度值，彩色图像则返回B、G、R三个分量。注意OpenCV读取图像是BGR存储显示，需要转换为RGB再进行图像处理。

灰度图像：返回值 = 图像(位置参数)

eg: test=img[88,42]

彩色图像：返回值 = 图像[位置元素, 0 | 1 | 2 ] 获取BGR三个通道像素

eg: blue=img[88,142,0] green=img[88,142,1] red=img[88,142,2]

2.修改图像

修改图像如果是灰度图像则直接赋值新像素即可，彩色图像依次给三个值赋值即可。

灰度图像：

img[88,142] = 255

彩色图像：

img[88,142, 0] = 255

img[88,142, 1] = 255

img[88,142, 2] = 255

彩色图像：方法二

img[88,142] = [255, 255, 255]

下面代码是获取像素及修改的操作。
# -*- coding:utf-8 -*-
import cv2

#读取图片
img = cv2.imread("test.jpg", cv2.IMREAD_UNCHANGED)
test = img[88,142]
print test
img[88,142] = [255, 255, 255]
print test

#分别获取BGR通道像素
blue = img[88,142,0]
print blue
green = img[88,142,1]
print green
red = img[88,142,2]
print red

#显示图像
cv2.imshow("Demo", img)

#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

#写入图像
cv2.imwrite("testyxz.jpg", img)

输出结果如下所示：

[158 107  64]

[255 255 255]

255

255

255
下面代码是将行为100到200、列150到250的像素区域设置为白色。
# -*- coding:utf-8 -*-
import cv2

#读取图片
img = cv2.imread("test.jpg", cv2.IMREAD_UNCHANGED)

#该区域设置为白色
img[100:200, 150:250] = [255,255,255]

#显示图像
cv2.imshow("Demo", img)

#等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

#写入图像
cv2.imwrite("testyxz.jpg", img)

运行结果如下图所示：



希望文章对大家有所帮助，如果有错误或不足之处，还请海涵。

（By：Eastmount 2018-08-16 夜11点 https://blog.csdn.net/Eastmount/）

2020年8月18新开的“娜璋AI安全之家”，主要围绕Python大数据分析、网络空间安全、人工智能、Web渗透及攻防技术进行讲解，同时分享CCF、SCI、南核北核论文的算法实现。娜璋之家会更加系统，并重构作者的所有文章，从零讲解Python和安全，写了近十年文章，真心想把自己所学所感所做分享出来，还请各位多多指教，真诚邀请您的关注！谢谢。