Python图像处理之图像与视频处理基础教程

2023-05-15 08:05:05 图像处理视频处理基础教程

图像与视频处理基础

0. 前言

图像处理是指在计算机上使用算法和代码对图像进行自动处理、操作和分析，而视频处理是图像处理的一种特殊情况(视频文件或视频流有连续的图像序列构成)。图像和视频处理在许多领域都有应用广泛的应用，如电视、摄影、机器人、遥感、医学诊断和工业检查等。
在本节中，我们将聚焦一些简单的图像和视频处理问题，用于帮助我们理解图像和视频的基本概念。在我们开始分析图像/视频之前，我们需要使用合适的数据结构将图像加载到内存中，并且能够将处理后的图像/视频保存到文件中；能够在计算机屏幕上实时可视化(绘制)图像能够帮助我们立即观察到图像处理算法对图像的处理结果。

1. 在 3D 空间中显示 RGB 图像颜色通道

1.1 图像表示

图像可以抽象为一个函数，并将其可视化，以进行进一步的分析/处理。灰度图像可以认为是像素位置的二元函数 f ( x , y ) f(x, y) f(x,y)， f ( x , y ) f(x, y) f(x,y) 将每个像素映射到其相应灰度强度级别( [0, 255] 中的整数或 [0, 1] 中的浮点数)，即：

对于 RGB 图像，有三个这样的函数，可以表示为：

其分别对应于每个通道及其色值，我们可以使用 matplotlib 库的三维绘图函数绘制以上函数，使用 python 代码在 3D 空间中单独绘制每个 RGB 通道。

1.2 在 3D 空间中绘制颜色通道

(1) 首先，导入所有必需的包。为了读取图像，我们需要 scikit-image 库的 io 模块中的 imread() 函数；由于我们将图像加载为 array 类型，因此需要 Numpy 操作数据类型 array；为了显示图像，我们将使用 matplotlib.pyplot 函数；对于 3D 图像的显示，我们需要使用 mpl_toolkit 库的 mplt3d 模块以及 matplotlib 库中的其他模块：

from skimage.io import imread
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FORMatStrFormatter

(2) 使用 plot_surface() 函数绘制通道的像素值，这是绘制 3D 图像的关键函数：

Axes3D.plot_surface(X, Y, Z, *args, **kwargs)

接下来，我们实现 plot_3d() 的函数，在以下代码中，X 轴和 Y 轴分别用于显示水平轴和垂直轴，Z 轴用于显示图像的深度。需要注意的是，x、y 和 z 的尺寸必须相同，cmap 用于显示不同像素值的颜色映射：

def plot_3d(x, y, z, cmap='Reds', title=''):
    fig = plt.figure(figsize=(15,15))
    ax = fig.GCa(projection='3d')
    # 曲面绘制
    surf = ax.plot_surface(x, y, z, cmap=cmap, linewidth=0, antialiased=False, rstride=2, cstride=2, alpha=0.5)
    ax.xaxis.set_major_locator(LinearLocator(10))
    ax.xaxis.set_major_formatter(FormatStrFormatter('%.02f'))
    ax.view_init(elev=10., azim=5)
    ax.set_title(title, size=20)
    plt.show()

(3) 从磁盘读取 RGB 图像，并使用 scikit-image 库 io 模块的 imread() 函数将其加载到内存中:

skimage.io.imread(fname, as_gray=False, plugin=None, flatten=None, **plugin_args)

使用 imread() 函数从文件加载图像：

im = imread('1.jpg')

(4) 然后，使用 Numpy 库的 arange() 和 meshbrid() 函数创建像素坐标 ( x , y ) (x, y) (x,y) 的二维网格：

y = np.arange(im.shape[0])
x = np.arange(im.shape[1])
x, y = np.meshgrid(x, y)

(5) 最后，将图像的红色、绿色和蓝色通道分别分配给相应变量，这些通道使用 plot_3D() 函数以 3D 方式显示：

z1 = im[...,0]
z2 = im[...,1]
z3 = im[...,2]

(6) 在 3D 空间中可视化图像，使用 plot_3d() 函数可视化 RGB 图像的颜色通道。使用 Z 轴作为深度轴，并从图像的高度中减去 y 轴值，以便将坐标原点从左上角移动到左侧中心点处。使用函数 plot_3d() 可视化红色通道：

plot_3d(z1, x, im.shape[1]-y, cmap='Reds', title='3D plot for the Red Channel')

红色通道的 3D 绘图结果如下所示：

从以上绘图结果可以看出，每个通道中的颜色深度和 3D 绘图结果在视觉上与原始 2D 图像类似。

2. 使用 scikit-video 读/写视频文件

2.1 scikit-video 库

在本节中，我们将学习如何使用 scikit-video 库函数从磁盘加载视频，该库使用 FFmpeg 软件执行视频 I/O，因此首先需要安装 FFmpeg 后再安装 scikit-video 模块：

pip3 install scikit-video

2.2 读/写视频文件

首先导入所有必需的包：

import skvideo.io
import numpy as np
import matplotlib.pyplot as plt

接下来，使用 FFmpegReader() 函数从磁盘读取视频文件，并随机显示视频中的一些图像帧。函数 FFmpegReader() 的用法如下：

skvideo.io.FFmpegReader(*args, **kwargs)

使用 FFmpeg 读取视频帧：

inputparameters = {}
outputparameters = {}
reader = skvideo.io.FFmpegReader('example.mp4',
                inputdict=inputparameters,
                outputdict=outputparameters)

2.3 提取视频文件属性

使用 getShape() 方法以及 FFmpegReader() 函数返回的对象获取视频的帧数、高度、宽度和通道数等属性：

# 读取视频文件属性
num_frames, height, width, num_channels = reader.getShape()
print(num_frames, height, width, num_channels)

2.4 读取并保存视频

使用 nextFrame() 方法从视频中读取帧。通过使用 NumPy 的 random.choice() 函数随机选择四个帧，并显示这些帧：

plt.figure(figsize=(20,10))

frame_list = np.random.choice(num_frames, 4)
i, j = 0, 1
for frame in reader.nextFrame():
    if i in frame_list:
        plt.subplot(2,2,j)
        plt.imshow(frame)
        plt.title("Frame {}".format(i), size=20)
        plt.axis('off')
        j += 1
    i += 1
plt.show()

二值图像是只有两个不同灰度值(黑色和白色)的图像，二值图像处理通常是图像处理应用程序的主要过程之一，例如，形态学图像处理算法通常需要输入二值图像开始。要计算二值图像，最简单的方法是使用阈值算法，高于阈值的像素变为白色，低于阈值的像素均变为黑色。
filters 模块中的 threshold_otsu() 函数能够对视频中的帧进行阈值处理，threshold_otsu() 函数能够将灰度图像转换为二值图像(在之后的学习中，我们会对其进行详细介绍)。
对每个颜色通道应用阈值以从图像帧中获得二值图像帧。使用 FFmpegWriter() 函数保存二值化视频，方法是按读取视频帧顺序依次叠加二值图像帧：

from skimage.color import rgb2gray
from skimage.filters import threshold_otsu

writer = skvideo.io.FFmpegWriter("r2_binary.mp4", outputdict={})
for frame in skvideo.io.vreader("r3.mp4"):
    frame = rgb2gray(frame)
    thresh = threshold_otsu(frame)
    binary = np.zeros((frame.shape[0], frame.shape[1], 3), dtype=np.uint8)
    binary[...,0] = binary[...,1] = binary[...,2] = 255*(frame > thresh).astype(np.uint8)
    writer.writeFrame(binary)
writer.close()

最后，读取刚刚保存的二进制视频，然后显示一些随机帧：

plt.figure(figsize=(20,10))

reader = skvideo.io.FFmpegReader("example_binary.mp4")
num_frames, height, width, num_channels = reader.getShape()
frame_list = np.random.choice(num_frames, 4)
i, j = 0, 1
for frame in reader.nextFrame():
    if i in frame_list:
        plt.subplot(2,2,j)
        plt.imshow(frame)
        plt.title("Frame {}".format(i), size=20)
        plt.axis('off')
        j += 1
    i += 1
plt.show()

3. 使用 OpenCV 从相机捕获实时视频

在本节中，我们将学习如何使用 OpenCV 库捕获视频并提取图像帧，同时我们将捕获摄像机(例如，笔记本电脑的内置网络摄像头或 USB 摄像头)录制的实时视频流。

(1) 首先导入所需的库：

import cv2
import matplotlib.pyplot as plt

(2) 要使用 OpenCV 捕获视频，我们需要创建一个 VideoCapture 对象，它的参数可以是设备索引(实时视频)或视频文件的名称(本地文件)：

vc = cv2.VideoCapture(0)
plt.ion()
if vc.isOpened(): # 读取第一帧
    is_capturing, frame = vc.read()    
    WEBcam_preview = plt.imshow(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))    
else:
    is_capturing = False

设备索引是指定摄像机的整数数字，通常，如果只有一台相机连接到计算机，只需传递 0 作为参数即可，如果有两台相机，则可以通过传递 1 来选择第二台相机，依次类推。
我们可以使用 isOpened() 方法检查 VideoCapture 对象是否正确初始化，如果正确初始化则返回 true。如果返回 true，那么我们可以使用函数 read() 读取第一帧以及所有后续帧。
read() 函数是从设备捕获数据的最方便的方法，它返回捕获的视频帧。如果没有捕获到任何帧(摄像机已断开连接，或者视频文件中没有更多帧)，则该方法返回 false；使用布尔变量 is_capturing 确定是否可以捕获帧。

(3) 一旦第一帧被正确读取，我们就可以在 while 循环中逐帧捕获，直到视频的最后一帧。最后，一定要调用 VideoCapture 对象上的 release() 函数来释放设备。以下代码演示了如何捕获实时视频流的前十帧。需要注意的是，OpenCV 使用 BGR 颜色格式，要显示具有真实 RGB 颜色的视频帧，必须使用转换函数 cv2.cvtColor(frame, cv2.color_BGR2RGB)：

frame_index = 1
while is_capturing:
    if frame_index > 10: break

    is_capturing, frame = vc.read()
    image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    webcam_preview.set_data(image)
    plt.title('Frame {0:d} '.format(frame_index))
    plt.draw()
    frame_index += 1
    try:    # 避免由 plt.pause 引起的 NotImplementedError
        plt.pause(2)
    except Exception:
        Pass
vc.release()

如果连接到计算机的相机设备可以正常工作，那么运行以上代码时，就可以看到相机捕获到的实时图像。此外， cv2.VideoCapture() 函数也可用于从磁盘读取视频文件，相对应的，可以使用 cv2.VideoWriter() 函数可将视频文件保存到本地磁盘文件中。

4. 实现 Gotham 图像滤镜

4.1 Gotham 图像滤镜

在本节中，我们将学习如何实现 Gotham 图像滤镜用于增强图像效果，用于加强理解如何操作图像像素并执行插值操作。下图显示了我们将用于实现图像滤镜的输入图像：

首先，导入所需的库。在本节中，我们将使用 PIL 库实现图像处理函数：

from PIL import Image
import numpy as np
import matplotlib.pyplot as plt

im = Image.open('images/Img_01_03.jpg')
print(np.max(im))

创建 Gotham 滤波器需要在输入图像上应用中间色调(红色)对比度增强，这需要通过使用 Numpy 库的 interp() 函数完成的，利用该函数实现通道插值。接下来，我们首先了解 NumPy 插值在一维情况空间中的工作原理。

4.2 一维线性插值

当图像按缩放因子调整大小时，需要执行一些像素插值，以便在现有像素之间填充新像素值，我们可以使用 NumPy interp() 函数执行插值操作。从 NumPy 文档中可以看到，interp() 函数的一维线性插值基本用法如下：

numpy.interp(x, left=None, right=None, period=None)

interp() 会返回具有给定离散数据点的函数的一维分段线性插值：

x_p = np.linspace(0, 2*np.pi, 10) # 在间隔[0，2π]中生成10个均匀间隔的数字序列
y_p = np.cos(x_p)
x = np.linspace(0, 2*np.pi, 50) # 在间隔[0，2π]中生成50个均匀间隔的数字序列
y = np.cos(x)
y_interp = np.interp(x, x_p, y_p)

plt.figure(figsize=(20,10))
plt.plot(x_p, y_p, 'o', label='reference points')
plt.plot(x, y_interp, '-x', label='interpolated')
plt.plot(x, y, '--', label='true')
plt.legend(prop={'size': 16})
plt.show()

假设我们希望(线性)插值区间 [ 0 , 2 π ] [0, 2π] [0,2π] 中余弦函数的值，最初区间中仅包含十个参考点。我们可以使用 interp() 函数计算剩余点处函数的值，从给定点处函数值开始，然后应用线性插值。橙色曲线表示由 interp() 函数估计的曲线，绿色曲线显示真实的余弦曲线：

4.3 图像插值

可以以类似的方式扩展以上代码，使用 interp() 函数计算 R (红色)通道的通道内插值结果，由于图像的红色通道值本质上是一个 2D 阵列(矩阵)，因此在将该函数应用于通道之前，需要执行以下操作：

将 2D 阵列展平为 1D 阵列(使用 NumPy 的 ravel() 函数)
使用 interp() 函数应用通道插值
将 1D 阵列重新整形为图像矩阵(使用 NumPy 的整形函数)

(1) 使用 np.interp() 函数，用 11 个参考点拉伸红色通道直方图：

r, g, b = im.split() # 分割图像通道为R、G和B
r_old = np.linspace(0,255,11)   # 参考点
r_new = [0., 12.75, 25.5, 51., 76.5, 127.5, 178.5, 204., 229.5, 242.25, 255.] # 参考点的新值

r1 = Image.fromarray((np.reshape(np.interp(np.array(r).ravel(), r_old, r_new),
                                 (im.height, im.width))).astype(np.uint8), mode='L')

(2) 然后，绘制图像和红色通道直方图：

plt.figure(figsize=(20,15))
plt.subplot(221)
plt.imshow(im)
plt.title('original', size=20)
plt.axis('off')
plt.subplot(222)
im1 = Image.merge('RGB', (r1, g, b))
plt.imshow(im1)
plt.axis('off')
plt.title('with red channel interpolation', size=20)
plt.subplot(223)
plt.hist(np.array(r).ravel())
plt.subplot(224)
plt.hist(np.array(r1).ravel())
plt.show()

下图显示了插值变换前后的图像：

(3) 通过使用以下代码，令黑色更接近蓝色值，我们将蓝色值增加了 7.65，并且使用函数 np.clip() 来确保新值保持在 0 到 255 区间内：

plt.figure(figsize=(20,10))
plt.subplot(121)
plt.imshow(im1)
plt.title('last image', size=20)
plt.axis('off')
b1 = Image.fromarray(np.clip(np.array(b) + 7.65, 0, 255).astype(np.uint8))
im1 = Image.merge('RGB', (r1, g, b1))
plt.subplot(122)
plt.imshow(im1)
plt.axis('off')
plt.title('with transformation', size=20)
plt.tight_layout()
plt.show()

其中，matplotlib 库的 subplot 模块用于显示子图，向当前图像中添加子图：

subplot(nrows, ncols, index, **kwargs)

如上图所示，使用 plt.subplot(121) 创建具有一行和两列子图的图像，并使用索引参数 index 指定绘图位置。

(4) 通过使用 PIL 库的 ImageEnhance 类中的 Enhance() 方法对图像执行较小的锐化：

class PIL.ImageEnhance.Sharpness(image)

ImageEnhance 类可用于调整图像的清晰度，

from PIL.ImageEnhance import Sharpness

plt.figure(figsize=(20,10))
plt.subplot(121)
plt.imshow(im1)
plt.title('last image', size=20)
plt.axis('off')
im2 = Sharpness(im1).enhance(3.0)
plt.subplot(122)
plt.imshow(im2)
plt.axis('off')
plt.title('with transformation', size=20)
plt.tight_layout()
plt.show()

(5) 减少蓝色通道的色调值，我们同样使用通道插值完成，但这次需要在 RGB 图像的蓝色通道上进行：

blue_old = np.linspace(0,255,17) # 参考点的像素值
blue_new = [0., 11.985, 30.09, 64.005, 81.09, 99.96, 107.1, 111.945, 121.125, 143.055, 147.9, 159.885, 171.105,
               186.915, 215.985, 235.875, 255.] # 参考点的新像素值

b2 = Image.fromarray((np.reshape(np.interp(np.array(b1).ravel(), blue_old, blue_new),
                                 (im.height, im.width))).astype(np.uint8), mode='L')

绘制图像以及蓝色通道直方图如下：

plt.figure(figsize=(20,15))
plt.subplot(221)
plt.imshow(im2)
plt.title('last image', size=20)
plt.axis('off')
plt.subplot(222)
im3 = Image.merge('RGB', (r1, g, b2))
plt.imshow(im3)
plt.axis('off')
plt.title('with blue channel interpolation', size=20)
plt.subplot(223)
plt.hist(np.array(b1).ravel(), normed=True)
plt.subplot(224)
plt.hist(np.array(b2).ravel(), normed=True)
plt.show()

(5) 最后，我们展示应用 Gotham 滤镜生成的最终输出图像：

plt.figure(figsize=(20,15))
plt.imshow(im3)
plt.axis('off')
plt.show()

小结

图像和视频是大数据时代重要的交流媒介，图像和视频处理是当今人工智能技术重点的研究领域。在本节中，我们学习了如何使用 Python 执行基本的图像/视频处理，我们首先学习在 3D 空间可视化 RGB 图像的三个通道；然后，介绍了如何捕获视频并提取图像帧；最后，我们展示了如何实现一种流形的图像滤镜 Gotham，用于理解如何操作图像像素并执行插值操作。

到此这篇关于Python图像处理之图像与视频处理基础教程的文章就介绍到这了,更多相关Python图像处理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

相关文章