计算机视觉的简单应用

元气少女橘子果酱

已于 2023-10-10 21:59:58 修改

阅读量202

点赞数 1

文章标签：图像处理人工智能

于 2023-09-26 01:12:35 首次发布

本文链接：https://blog.csdn.net/weixin_74108910/article/details/133284414

版权

基于opencv图片加载、显示、保存
RGB通道转换，分离（RGB通道单独显示）
正确使用matplotlib，使用subplot画子图
RGB<->HSV，单独显示H\S\V通道
灰度图直方图均衡化
彩色图直方图均衡化
椒盐噪声函数和高斯噪声函数
图片（灰度）加噪声
图片平滑降噪（平滑，中值滤波，高斯滤波），对比不同大小窗口
sobel算子
拉普拉斯算子
canny算子边缘检测
.有必要的情况，要将原图和处理后的图片放在一起对比

1.conda虚拟环境，opencv，jupyter lab 2.jupyter使用，markdown文档编写

图片路径不要有中文，能省掉很多麻烦！！！！！！

在写代码之前，先插入这几个模块！！！

!pip install opencv-python
!pip install matplotlib
!pip install pillow
!pip install numpy

先安装软件包

1. OpenCV-Python：OpenCV是一个开源计算机视觉库，它提供了许多用于处理图像和视频的函数和算法。OpenCV-Python是OpenCV的Python接口，它使得使用Python编程语言更加方便。

2. Matplotlib：Matplotlib是一个用于绘制二维图形的Python库。它可以创建各种类型的图表，包括线图、散点图、柱状图、饼图等。Matplotlib非常强大且易于使用，是数据可视化的常用工具。

3. Pillow：Pillow是一个用于图像处理的Python库，它是Python Imaging Library（PIL）的一个分支。Pillow提供了许多用于加载、处理和保存图像的函数和方法。你可以使用Pillow来调整图像大小、裁剪图像、添加滤镜等。

4. NumPy：NumPy是一个用于科学计算的Python库，它提供了高效的多维数组对象和用于处理这些数组的函数。NumPy的核心功能是对数组进行数值计算和操作，包括线性代数、傅里叶变换、随机数生成等。NumPy是许多其他科学计算库的基础。

PS：有些我用的是.jpg格式，有些用的是.jpeg格式，都是一张照片，有些照片换个格式就能跑起来了当时

1.基于opencv图片加载、显示、保存

import cv2

image_path = r"D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg"
image = cv2.imread(image_path)

if image is None:
    print("Failed to load image:", image_path)
else:
    print("Image loaded successfully.")

gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
//我先检测一下图片在不在我的路径里面

我的检测路径结果在噢！！！（路径自己复制自己的照片，不建议特别大的像素，我第一次用了我航拍素材的冈仁波齐全景图，给个大疆像素太大难跑起来哈哈哈！！！！）

接着我实现图片，加载，显示，但是保存我没写出来，假如有大神请在评论区写一下哈哈哈哈，谢谢

import cv2
import matplotlib.pyplot as plt

# 图片路径
image_path = r'D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg'

# 读取图片
image = cv2.imread(image_path)

# 将图片从BGR通道转换为RGB通道
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# 显示图片
plt.imshow(rgb_image)

# 关闭坐标轴
plt.axis('off')

# 显示图片
plt.show()

具体注释如上

结果显示

2.RGB通道转换，分离（RGB通道单独显示）

from PIL import Image  # 导入PIL库，用于处理图像

image_path = 'C:\\Users\\南宫洛玥\\Desktop\\4ace4d51af416be286652ae1ee43d82a.jpeg'  # 图像路径
image = Image.open(image_path)  # 打开图像

image = image.convert('RGB')  # 将图像转换为RGB模式

red_channel, green_channel, blue_channel = image.split()  # 将图像拆分为红色通道、绿色通道和蓝色通道

import matplotlib.pyplot as plt  # 导入matplotlib库，用于显示图像

plt.imshow(red_channel, cmap='gray')  # 显示红色通道图像，使用灰度颜色映射
plt.title('Red Channel')  # 设置图像标题
plt.axis('off')  # 关闭坐标轴显示
plt.show()  # 显示图像

plt.imshow(green_channel, cmap='gray')  # 显示绿色通道图像，使用灰度颜色映射
plt.title('Green Channel')  # 设置图像标题
plt.axis('off')  # 关闭坐标轴显示
plt.show()  # 显示图像

plt.imshow(blue_channel, cmap='gray')  # 显示蓝色通道图像，使用灰度颜色映射
plt.title('Blue Channel')  # 设置图像标题
plt.axis('off')  # 关闭坐标轴显示
plt.show()  # 显示图像
//具体注释，一定要看懂代码是什么意思噢！！

这段代码打开了一张图像，并将其转换为RGB模式。然后，它将图像分离成红色通道、绿色通道和蓝色通道，并使用matplotlib库显示了每个通道的灰度图像。最后，它显示了红色通道、绿色通道和蓝色通道的图像。

结果显示

3.正确使用matplotlib，使用subplot画子图

import matplotlib.pyplot as plt
from PIL import Image

# 图片路径
image_path = r"C:\Users\南宫洛玥\Desktop\4ace4d51af416be286652ae1ee43d82a.jpeg"

# 打开图片
image = Image.open(image_path)

# 创建一个包含两个子图的画布
plt.subplot(1, 2, 1)  # 第一个子图
plt.imshow(image)  # 显示原始图片
plt.title('Original Image')

plt.subplot(1, 2, 2)  # 第二个子图
gray_image = image.convert('L')  # 将图片转换为灰度图
plt.imshow(gray_image, cmap='gray')  # 使用灰度图像的颜色映射
plt.title('Grayscale Image')

plt.tight_layout()  # 调整子图之间的间距

plt.show()  # 显示图片

首先导入需要使用的库，matplotlib.pyplot用于绘制图片，PIL.Image用于处理图片。
定义图片路径image_path，这里使用了一个绝对路径，你可以根据实际情况进行修改。
使用Image.open()函数打开图片，得到一个Image对象。
使用plt.subplot()函数创建一个包含两个子图的画布，参数(1, 2, 1)指定了1行2列的布局，并将第一个子图设置为当前子图。
使用plt.imshow()函数显示原始图片，plt.title()函数设置子图标题为"Original Image"。
使用plt.subplot()函数将第二个子图设置为当前子图。
使用image.convert('L')将原始图片转换为灰度图，得到一个新的灰度图像gray_image。
使用plt.imshow()函数显示灰度图像，cmap='gray'参数指定了使用灰度图像的颜色映射。
使用plt.title()函数设置子图标题为"Grayscale Image"。
使用plt.tight_layout()函数调整子图之间的间距。

最后使用plt.show()函数显示图片。

4.RGB<->HSV，单独显示H\S\V通道

import matplotlib.pyplot as plt
from PIL import Image

# 设置图片路径
image_path = 'C:\\Users\\南宫洛玥\\Desktop\\4ace4d51af416be286652ae1ee43d82a.jpeg'
# 打开图片
image = Image.open(image_path)

# 将图片转换为RGB模式
image_rgb = image.convert('RGB')

# 将RGB图片转换为HSV模式
image_hsv = image_rgb.convert('HSV')

# 分离HSV图片的通道
h_channel, s_channel, v_channel = image_hsv.split()

# 创建一个包含3个子图的画布
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))

# 在第一个子图中显示H通道图像，使用灰度色彩映射
ax1.imshow(h_channel, cmap='gray')
ax1.set_title('H Channel')

# 在第二个子图中显示S通道图像，使用灰度色彩映射
ax2.imshow(s_channel, cmap='gray')
ax2.set_title('S Channel')

# 在第三个子图中显示V通道图像，使用灰度色彩映射
ax3.imshow(v_channel, cmap='gray')
ax3.set_title('V Channel')

# 关闭子图的坐标轴
for ax in (ax1, ax2, ax3):
    ax.axis('off')

# 显示画布
plt.show()

用了matplotlib.pyplot库来绘制图像，并使用PIL.Image库来处理图像。首先，通过Image.open()函数打开图片，并将其转换为RGB模式。然后，将RGB图片转换为HSV模式，使用convert()函数并传入参数'HSV'。接下来，通过split()函数分离HSV图片的通道，得到H、S、V通道的图像。然后，创建一个包含3个子图的画布，并在每个子图中显示对应通道的图像。最后，关闭子图的坐标轴，并显示画布。

5.灰度图直方图均衡化

import cv2
import matplotlib.pyplot as plt

# 图片路径
image_path = r'D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg'

# 使用OpenCV加载图片
image = cv2.imread(image_path)

# 将彩色图片转换为灰度图
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 对灰度图进行直方图均衡化
equalized_image = cv2.equalizeHist(gray_image)

# 创建一个包含两个子图的画布
fig, axes = plt.subplots(1, 2, figsize=(10, 5))

# 在第一个子图中显示原始彩色图片
axes[0].imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
axes[0].set_title('Original Image')
axes[0].axis('off')

# 在第二个子图中显示直方图均衡化后的灰度图
axes[1].imshow(equalized_image, cmap='gray')
axes[1].set_title('Equalized Image')
axes[1].axis('off')

# 显示画布
plt.show()

用OpenCV的imread函数加载一张图片。接下来，使用cvtColor函数将彩色图片转换为灰度图。然后，使用equalizeHist函数对灰度图进行直方图均衡化。最后，使用subplots函数创建一个包含两个子图的画布，并在第一个子图中显示原始彩色图片，在第二个子图中显示直方图均衡化后的灰度图。最后调用plt.show()显示画布。

6.彩色直方图均衡化

import cv2
import matplotlib.pyplot as plt

# 图片路径
image_path = r'D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg'

# 读取图片
image = cv2.imread(image_path)

# 将图片从BGR颜色空间转换为YUV颜色空间
image_yuv = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)

# 对Y通道进行直方图均衡化
image_yuv[:,:,0] = cv2.equalizeHist(image_yuv[:,:,0])

# 将图片从YUV颜色空间转换回BGR颜色空间
equalized_image = cv2.cvtColor(image_yuv, cv2.COLOR_YUV2BGR)

# 创建一个10x5英寸的画布
plt.figure(figsize=(10, 5))

# 在画布上创建两个子图
plt.subplot(121), plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)), plt.title('Original Image')
plt.subplot(122), plt.imshow(cv2.cvtColor(equalized_image, cv2.COLOR_BGR2RGB)), plt.title('Equalized Image')

# 显示画布
plt.show()

使用OpenCV和matplotlib库对图片进行了处理和展示。首先，使用cv2.imread()函数读取了指定路径下的图片。然后，使用cv2.cvtColor()函数将图片从BGR颜色空间转换为YUV颜色空间。接下来，对Y通道进行直方图均衡化，使用cv2.equalizeHist()函数实现。然后，再次使用cv2.cvtColor()函数将图片从YUV颜色空间转换回BGR颜色空间。最后，使用matplotlib库创建一个画布，并在画布上创建两个子图，分别展示原始图片和均衡化后的图片。最后调用plt.show()函数显示画布。

7.1椒盐噪声

from PIL import Image
import numpy as np
import random
import pylab as py


original_image = Image.open(r'D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg')


grayscale_image = original_image.convert('L')


original_array = np.array(original_image)
grayscale_array = np.array(grayscale_image)


SNR = 0.6


noiseNum = int((1 - SNR) * grayscale_array.shape[0] * grayscale_array.shape[1])


for i in range(noiseNum):
    randX = random.randint(0, grayscale_array.shape[0] - 1)
    randY = random.randint(0, grayscale_array.shape[1] - 1)
    if random.randint(0, 1) == 0:
        grayscale_array[randX, randY] = 0
    else:
        grayscale_array[randX, randY] = 255


py.subplot(121)
py.imshow(original_array)
py.title('Original Color Image')

py.subplot(122)
py.imshow(grayscale_array, cmap='gray')  
py.title('Modified Grayscale Image')

py.show()

这段代码打开了一张图像，并将其转换为numpy数组。然后定义了一个函数来添加椒盐噪声。函数根据指定的椒盐比例和噪声数量计算需要添加的盐和椒的数量，然后在图像数组上随机选择坐标，并将对应的像素值设置为255和0。最后，通过使用matplotlib库来显示原始图像和添加了噪声的图像。

7.2高斯噪声

高斯噪声尊嘟好好看！！！！！有点老式相机的感觉

import numpy as np
from PIL import Image

# 定义图片路径
image_path = r'C:\Users\南宫洛玥\Desktop\4ace4d51af416be286652ae1ee43d82a.jpeg'
# 打开图片
image = Image.open(image_path)

# 将图片转换为numpy数组
image_array = np.array(image)

# 定义添加高斯噪声的函数
def add_gaussian_noise(image_array, mean, std_dev):
    # 生成均值为mean，标准差为std_dev的高斯噪声数组
    noise = np.random.normal(mean, std_dev, image_array.shape)
    # 将噪声添加到原始图像数组上
    noisy_image_array = image_array + noise
    # 将图像数组的像素值限制在0到255之间，并转换为无符号整数类型
    noisy_image_array = np.clip(noisy_image_array, 0, 255).astype(np.uint8)
    return noisy_image_array

# 设置高斯噪声的均值和标准差
mean = 0  
std_dev = 20  
# 添加高斯噪声到图像数组上
noisy_image_array = add_gaussian_noise(image_array, mean, std_dev)

# 将噪声图像数组转换为图片对象
noisy_image = Image.fromarray(noisy_image_array)

import matplotlib.pyplot as plt

# 创建一个包含两个子图的图像画布
fig, axes = plt.subplots(1, 2, figsize=(10, 5))
# 显示原始图像
axes[0].imshow(image)
axes[0].set_title('Original Image')
axes[0].axis('off')
# 显示添加了噪声的图像
axes[1].imshow(noisy_image)
axes[1].set_title('Noisy Image')
axes[1].axis('off')

# 显示图像
plt.show()

这段代码中，我们首先导入了需要的库，然后定义了图片路径并打开了图片。接着，我们将图片转换为numpy数组。然后，我们定义了一个函数add_gaussian_noise，用于向图像数组中添加高斯噪声。在函数中，我们使用np.random.normal生成均值为mean，标准差为std_dev的高斯噪声数组，然后将噪声添加到原始图像数组上。为了保证图像的像

8.图片（灰度）加噪声

import cv2
import matplotlib.pyplot as plt
import numpy as np

# 设置图像路径
image_path = r'D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg'

# 读取图像
image = cv2.imread(image_path)

# 将图像转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 创建与灰度图像相同大小的全零矩阵
noise_image = np.zeros_like(gray_image)
# 生成服从均值为0，标准差为50的高斯随机数矩阵
cv2.randn(noise_image, 0, 50)
# 将随机数矩阵添加到灰度图像中，产生带有噪声的灰度图像
noisy_gray_image = cv2.add(gray_image, noise_image)

# 创建一个1行3列的图像子图
fig, ax = plt.subplots(1, 3, figsize=(12, 4))

# 显示原始图像
ax[0].imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
ax[0].set_title('Original Image')
ax[0].axis('off')

# 显示灰度图像
ax[1].imshow(gray_image, cmap='gray')
ax[1].set_title('Grayscale Image')
ax[1].axis('off')

# 显示带有噪声的灰度图像
ax[2].imshow(noisy_gray_image, cmap='gray')
ax[2].set_title('Grayscale Image with Noise')
ax[2].axis('off')

# 显示图像
plt.show()

导入所需的库：cv2用于图像处理，matplotlib用于显示图像，numpy用于生成随机数矩阵。
设置图像路径：将图像的路径保存到变量image_path中。
读取图像：使用cv2.imread()函数读取图像，将其保存到变量image中。
将图像转换为灰度图像：使用cv2.cvtColor()函数将彩色图像转换为灰度图像，将其保存到变量gray_image中。
创建与灰度图像相同大小的全零矩阵：使用np.zeros_like()函数创建一个与gray_image大小相同的全零矩阵，将其保存到变量noise_image中。
生成服从均值为0，标准差为50的高斯随机数矩阵：使用cv2.randn()函数生成一个服从均值为0，标准差为50的高斯随机数矩阵，将其保存到变量noise_image中。
将随机数矩阵添加到灰度图像中，产生带有噪声的灰度图像：使用cv2.add()函数将gray_image和noise_image相加，将结果保存到变量noisy_gray_image中。
创建一个1行3列的图像子图：使用plt.subplots()函数创建一个包含1行3列子图的图像，将其保存到变量fig和ax中。
显示原始图像：使用ax[0].imshow()函数显示原始图像，使用ax[0].set_title()函数设置子图标题，使用ax[0].axis('off')函数关闭坐标轴显示。
显示灰度图像：使用ax[1].imshow()函数显示灰度图像，使用ax[1].set_title()函数设置子图标题，使用ax[1].axis('off')函数关闭坐标轴显示。
显示带有噪声的灰度图像：使用ax[2].imshow()函数显示带有噪声的灰度图像，使用ax[2].set_title()函数设置子图标题，使用ax[2].axis('off')函数关闭坐标轴显示。
显示图像：使用plt.show()函数显示图像。

9 中值滤波，高斯滤波降噪

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 定义图像文件路径
image_path = r'D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg'

# 读取图像
image = cv2.imread(image_path)

# 将图像转换为灰度图像
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 生成椒盐噪声
noise = np.random.normal(0, 1, gray.shape)
noisy_image = np.clip(gray + noise, 0, 255).astype(np.uint8)

# 使用中值滤波去噪
denoised_median = cv2.medianBlur(noisy_image, 5)

# 使用高斯滤波去噪
denoised_gaussian = cv2.GaussianBlur(noisy_image, (5, 5), 0)

# 创建一个包含3个子图的图像窗口
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# 在第一个子图中显示原始图像
axes[0].imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
axes[0].axis('off')
axes[0].set_title('Original Image')

# 在第二个子图中显示加入噪声的图像
axes[1].imshow(noisy_image, cmap='gray')
axes[1].axis('off')
axes[1].set_title('Noisy Image')

# 在第三个子图中显示经过中值滤波去噪后的图像
axes[2].imshow(denoised_median, cmap='gray')
axes[2].axis('off')
axes[2].set_title('Denoised (Median) Image')

# 显示图像窗口
plt.show()

这段代码首先读取了一张图像，然后将其转换为灰度图像。接下来，通过生成服从正态分布的随机数来生成椒盐噪声，并将其加入到灰度图像中。然后，使用中值滤波和高斯滤波对加噪图像进行去噪处理。

最后，使用Matplotlib库创建了一个包含3个子图的图像窗口，分别显示了原始图像、加噪图像和经过中值滤波去噪后的图像。

10.sobel算子

import cv2
import matplotlib.pyplot as plt

# 定义图像路径
image_path = r"D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg"

# 读取图像
image = cv2.imread(image_path)

# 将图像转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 使用Sobel算子进行边缘检测
sobel_x = cv2.Sobel(gray_image, cv2.CV_64F, 1, 0, ksize=3)
sobel_y = cv2.Sobel(gray_image, cv2.CV_64F, 0, 1, ksize=3)
# 将x方向和y方向的边缘图像按权重叠加
sobel_image = cv2.addWeighted(sobel_x, 0.5, sobel_y, 0.5, 0)

# 创建一个包含两个子图的画布
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))

# 在第一个子图中绘制原始图像
ax1.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
ax1.set_title('Original Image')
ax1.axis('off')

# 在第二个子图中绘制Sobel边缘检测结果
ax2.imshow(sobel_image, cmap='gray')
ax2.set_title('Sobel Edge Detection')
ax2.axis('off')

# 显示画布
plt.show()

11.拉普拉斯算子

import cv2
import matplotlib.pyplot as plt

# 图像路径
image_path = r"D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg"

# 读取图像
image = cv2.imread(image_path)

# 将图像转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 使用Laplacian算子进行边缘检测
laplacian_image = cv2.Laplacian(gray_image, cv2.CV_64F)

# 创建一个包含两个子图的画布
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))

# 在第一个子图上绘制原始图像
ax1.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
ax1.set_title('Original Image')
ax1.axis('off')

# 在第二个子图上绘制Laplacian边缘检测后的图像
ax2.imshow(laplacian_image, cmap='gray')
ax2.set_title('Laplacian Edge Detection')
ax2.axis('off')

# 显示图像
plt.show()

12.canny算子边缘检测

# 导入所需的库
import cv2
import matplotlib.pyplot as plt

# 定义图像路径
image_path = r"D:\WeChat Files\All Users\4ace4d51af416be286652ae1ee43d82a.jpg"

# 使用OpenCV读取图像
image = cv2.imread(image_path)

# 将图像转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 使用Canny算法进行边缘检测
canny_image = cv2.Canny(gray_image, 100, 200)

# 创建一个包含两个子图的画布
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 5))

# 在第一个子图中绘制原始图像
ax1.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
ax1.set_title('Original Image')
ax1.axis('off')

# 在第二个子图中绘制Canny边缘检测结果
ax2.imshow(canny_image, cmap='gray')
ax2.set_title('Canny Edge Detection')
ax2.axis('off')

# 显示画布
plt.show()

元气少女橘子果酱

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
计算机视觉的简单应用

基于opencv图片加载、显示、保存RGB通道转换，分离（RGB通道单独显示）正确使用matplotlib，使用subplot画子图RGBHSV，单独显示H\S\V通道灰度图直方图均衡化彩色图直方图均衡化椒盐噪声函数和高斯噪声函数图片（灰度）加噪声图片平滑降噪（平滑，中值滤波，高斯滤波），对比不同大小窗口sobel算子拉普拉斯算子canny算子边缘检测
复制链接

扫一扫