NumPy图像处理基础操作详解新手必看的实用指南包含大量实例和代码演示助你快速提升图像处理技能

威震华夏关云长

引言

NumPy是Python中用于科学计算的核心库，它提供了高性能的多维数组对象以及用于处理这些数组的工具。在图像处理领域，NumPy扮演着至关重要的角色，因为图像本质上就是多维数组（矩阵）。例如，灰度图像可以表示为二维数组，而彩色图像（RGB）则可以表示为三维数组。掌握NumPy进行图像处理的基础操作，不仅能帮助你理解图像处理的底层原理，还能为你后续学习更高级的图像处理技术（如OpenCV、PIL等）打下坚实的基础。

本文将详细介绍NumPy在图像处理中的基础操作，包括图像的加载与显示、基本图像操作、颜色空间转换、图像滤波与增强、图像算术运算等内容，并通过大量实例和代码演示，帮助你快速提升图像处理技能。

NumPy基础

在开始图像处理之前，我们需要先了解NumPy的一些基础知识。

NumPy数组

NumPy的核心是ndarray对象，它是一个快速、灵活的大型数据集容器。我们可以使用NumPy来创建和操作这些数组。

2. import numpy as np
4. # 创建一维数组
5. arr1 = np.array([1, 2, 3, 4, 5])
6. print("一维数组:", arr1)
8. # 创建二维数组
9. arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
10. print("二维数组:\n", arr2)
12. # 创建三维数组
13. arr3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
14. print("三维数组:\n", arr3)
16. # 查看数组属性
17. print("数组形状:", arr2.shape)  # 输出: (3, 3)
18. print("数组维度:", arr2.ndim)  # 输出: 2
19. print("数组元素类型:", arr2.dtype)  # 输出: int64

复制代码

NumPy数组操作

NumPy提供了丰富的数组操作方法，这些方法在图像处理中非常有用。

2. import numpy as np
4. # 创建一个3x3的数组
5. arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
7. # 数组切片
8. print("第一行:", arr[0, :])  # 输出: [1 2 3]
9. print("第一列:", arr[:, 0])  # 输出: [1 4 7]
11. # 数组变形
12. reshaped_arr = arr.reshape(1, 9)  # 将3x3数组变形为1x9数组
13. print("变形后的数组:", reshaped_arr)
15. # 数组转置
16. transposed_arr = arr.T
17. print("转置后的数组:\n", transposed_arr)
19. # 数组计算
20. print("数组元素求和:", np.sum(arr))  # 输出: 45
21. print("数组元素平均值:", np.mean(arr))  # 输出: 5.0
22. print("数组元素最大值:", np.max(arr))  # 输出: 9
23. print("数组元素最小值:", np.min(arr))  # 输出: 1

复制代码

图像的加载与显示

在开始处理图像之前，我们需要学习如何加载和显示图像。虽然NumPy本身不提供图像I/O功能，但我们可以结合其他库（如PIL、matplotlib）来实现这一功能。

使用PIL加载图像

Python Imaging Library (PIL) 或其分支 Pillow 是Python中常用的图像处理库。我们可以使用PIL加载图像，然后将其转换为NumPy数组进行处理。

2. import numpy as np
3. from PIL import Image
4. import matplotlib.pyplot as plt
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = Image.open(image_path)
10. # 将PIL图像转换为NumPy数组
11. img_array = np.array(img)
13. # 显示图像信息
14. print("图像形状:", img_array.shape)
15. print("图像数据类型:", img_array.dtype)
16. print("图像大小:", img.size)
18. # 显示图像
19. plt.imshow(img)
20. plt.axis('off')  # 不显示坐标轴
21. plt.show()

复制代码

使用matplotlib加载和显示图像

Matplotlib是Python中常用的绘图库，它也提供了图像加载和显示的功能。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 显示图像信息
11. print("图像形状:", img.shape)
12. print("图像数据类型:", img.dtype)
14. # 显示图像
15. plt.imshow(img)
16. plt.axis('off')  # 不显示坐标轴
17. plt.show()

复制代码

保存图像

处理完图像后，我们可能需要将结果保存下来。我们可以使用PIL或matplotlib来实现这一功能。

2. import numpy as np
3. from PIL import Image
4. import matplotlib.pyplot as plt
6. # 假设我们有一个NumPy数组表示的图像
7. # 这里我们创建一个随机的RGB图像作为示例
8. height, width = 200, 300
9. img_array = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
11. # 使用PIL保存图像
12. img = Image.fromarray(img_array)
13. img.save("random_image.jpg")
15. # 使用matplotlib保存图像
16. plt.imsave("random_image_matplotlib.jpg", img_array)

复制代码

基本图像操作

现在我们已经学会了如何加载和显示图像，接下来让我们学习一些基本的图像操作。

图像裁剪

图像裁剪是指从图像中提取一个矩形区域。在NumPy中，这可以通过数组切片来实现。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 裁剪图像 [y_start:y_end, x_start:x_end]
11. # 注意：在NumPy数组中，第一个维度是高度（y轴），第二个维度是宽度（x轴）
12. cropped_img = img[100:400, 200:500]  # 裁剪从(200,100)到(500,400)的区域
14. # 显示原始图像和裁剪后的图像
15. plt.figure(figsize=(10, 5))
17. plt.subplot(1, 2, 1)
18. plt.imshow(img)
19. plt.title("原始图像")
20. plt.axis('off')
22. plt.subplot(1, 2, 2)
23. plt.imshow(cropped_img)
24. plt.title("裁剪后的图像")
25. plt.axis('off')
27. plt.tight_layout()
28. plt.show()

复制代码

图像旋转

图像旋转是另一种常见的图像操作。我们可以使用NumPy的rot90函数来实现简单的90度倍数旋转，或者使用更复杂的变换来实现任意角度的旋转。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 旋转90度（逆时针）
11. rotated_90 = np.rot90(img)
13. # 旋转180度
14. rotated_180 = np.rot90(img, 2)
16. # 旋转270度（或顺时针90度）
17. rotated_270 = np.rot90(img, 3)
19. # 显示原始图像和旋转后的图像
20. plt.figure(figsize=(12, 8))
22. plt.subplot(2, 2, 1)
23. plt.imshow(img)
24. plt.title("原始图像")
25. plt.axis('off')
27. plt.subplot(2, 2, 2)
28. plt.imshow(rotated_90)
29. plt.title("旋转90度")
30. plt.axis('off')
32. plt.subplot(2, 2, 3)
33. plt.imshow(rotated_180)
34. plt.title("旋转180度")
35. plt.axis('off')
37. plt.subplot(2, 2, 4)
38. plt.imshow(rotated_270)
39. plt.title("旋转270度")
40. plt.axis('off')
42. plt.tight_layout()
43. plt.show()

复制代码

如果要实现任意角度的旋转，我们可以使用scipy.ndimage库中的rotate函数：

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import rotate
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 旋转45度
12. rotated_45 = rotate(img, 45, reshape=False)
14. # 旋转30度
15. rotated_30 = rotate(img, 30, reshape=False)
17. # 显示原始图像和旋转后的图像
18. plt.figure(figsize=(15, 5))
20. plt.subplot(1, 3, 1)
21. plt.imshow(img)
22. plt.title("原始图像")
23. plt.axis('off')
25. plt.subplot(1, 3, 2)
26. plt.imshow(rotated_45)
27. plt.title("旋转45度")
28. plt.axis('off')
30. plt.subplot(1, 3, 3)
31. plt.imshow(rotated_30)
32. plt.title("旋转30度")
33. plt.axis('off')
35. plt.tight_layout()
36. plt.show()

复制代码

图像缩放

图像缩放是指改变图像的大小。我们可以使用NumPy的resize函数或scipy.ndimage中的zoom函数来实现。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import zoom
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 获取原始图像尺寸
12. original_height, original_width = img.shape[:2]
13. print(f"原始图像尺寸: {original_width}x{original_height}")
15. # 使用NumPy的resize函数进行缩放
16. # 将图像缩小到原来的一半
17. resized_half = np.array(Image.fromarray(img).resize((original_width//2, original_height//2)))
19. # 将图像放大到原来的两倍
20. resized_double = np.array(Image.fromarray(img).resize((original_width*2, original_height*2)))
22. # 使用scipy.ndimage的zoom函数进行缩放
23. # 将图像缩小到原来的一半
24. zoomed_half = zoom(img, 0.5)
26. # 将图像放大到原来的两倍
27. zoomed_double = zoom(img, 2)
29. # 显示原始图像和缩放后的图像
30. plt.figure(figsize=(15, 10))
32. plt.subplot(2, 3, 1)
33. plt.imshow(img)
34. plt.title("原始图像")
35. plt.axis('off')
37. plt.subplot(2, 3, 2)
38. plt.imshow(resized_half)
39. plt.title("缩小一半 (NumPy resize)")
40. plt.axis('off')
42. plt.subplot(2, 3, 3)
43. plt.imshow(resized_double)
44. plt.title("放大两倍 (NumPy resize)")
45. plt.axis('off')
47. plt.subplot(2, 3, 4)
48. plt.imshow(img)
49. plt.title("原始图像")
50. plt.axis('off')
52. plt.subplot(2, 3, 5)
53. plt.imshow(zoomed_half)
54. plt.title("缩小一半 (scipy zoom)")
55. plt.axis('off')
57. plt.subplot(2, 3, 6)
58. plt.imshow(zoomed_double)
59. plt.title("放大两倍 (scipy zoom)")
60. plt.axis('off')
62. plt.tight_layout()
63. plt.show()

复制代码

图像翻转

图像翻转是指沿水平轴或垂直轴翻转图像。我们可以使用NumPy的flip函数来实现。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 水平翻转（沿垂直轴）
11. flipped_horizontal = np.fliplr(img)
13. # 垂直翻转（沿水平轴）
14. flipped_vertical = np.flipud(img)
16. # 水平和垂直翻转
17. flipped_both = np.flip(img)
19. # 显示原始图像和翻转后的图像
20. plt.figure(figsize=(10, 8))
22. plt.subplot(2, 2, 1)
23. plt.imshow(img)
24. plt.title("原始图像")
25. plt.axis('off')
27. plt.subplot(2, 2, 2)
28. plt.imshow(flipped_horizontal)
29. plt.title("水平翻转")
30. plt.axis('off')
32. plt.subplot(2, 2, 3)
33. plt.imshow(flipped_vertical)
34. plt.title("垂直翻转")
35. plt.axis('off')
37. plt.subplot(2, 2, 4)
38. plt.imshow(flipped_both)
39. plt.title("水平和垂直翻转")
40. plt.axis('off')
42. plt.tight_layout()
43. plt.show()

复制代码

图像颜色空间转换

在图像处理中，我们经常需要将图像从一种颜色空间转换到另一种颜色空间。最常见的转换是将彩色图像（RGB）转换为灰度图像。

RGB转灰度

RGB图像转换为灰度图像有多种方法，其中最常用的是加权平均法。我们可以使用NumPy来实现这一转换。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 方法1：简单平均法
11. gray_avg = np.mean(img, axis=2)
13. # 方法2：加权平均法（更符合人眼感知）
14. # 灰度 = 0.299 * R + 0.587 * G + 0.114 * B
15. weights = [0.299, 0.587, 0.114]
16. gray_weighted = np.dot(img[..., :3], weights)
18. # 显示原始图像和灰度图像
19. plt.figure(figsize=(15, 5))
21. plt.subplot(1, 3, 1)
22. plt.imshow(img)
23. plt.title("原始图像")
24. plt.axis('off')
26. plt.subplot(1, 3, 2)
27. plt.imshow(gray_avg, cmap='gray')
28. plt.title("简单平均灰度")
29. plt.axis('off')
31. plt.subplot(1, 3, 3)
32. plt.imshow(gray_weighted, cmap='gray')
33. plt.title("加权平均灰度")
34. plt.axis('off')
36. plt.tight_layout()
37. plt.show()

复制代码

RGB转HSV

HSV（色相、饱和度、明度）是另一种常用的颜色空间。我们可以使用colorsys模块将RGB转换为HSV。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. import colorsys
7. def rgb_to_hsv(rgb_image):
8.     """将RGB图像转换为HSV图像"""
9.     # 确保输入值在0-1范围内
10.     if rgb_image.dtype == np.uint8:
11.         rgb_image = rgb_image / 255.0
12.    
13.     # 创建空的HSV图像
14.     hsv_image = np.zeros_like(rgb_image)
15.    
16.     # 遍历每个像素
17.     for i in range(rgb_image.shape[0]):
18.         for j in range(rgb_image.shape[1]):
19.             r, g, b = rgb_image[i, j]
20.             h, s, v = colorsys.rgb_to_hsv(r, g, b)
21.             hsv_image[i, j] = [h, s, v]
22.    
23.     return hsv_image
25. # 加载图像
26. image_path = "example.jpg"  # 替换为你的图像路径
27. img = mpimg.imread(image_path)
29. # 转换为HSV
30. hsv_img = rgb_to_hsv(img)
32. # 显示HSV通道
33. plt.figure(figsize=(15, 5))
35. plt.subplot(1, 4, 1)
36. plt.imshow(img)
37. plt.title("原始RGB图像")
38. plt.axis('off')
40. plt.subplot(1, 4, 2)
41. plt.imshow(hsv_img[:, :, 0], cmap='hsv')
42. plt.title("色相 (H)")
43. plt.axis('off')
45. plt.subplot(1, 4, 3)
46. plt.imshow(hsv_img[:, :, 1], cmap='gray')
47. plt.title("饱和度 (S)")
48. plt.axis('off')
50. plt.subplot(1, 4, 4)
51. plt.imshow(hsv_img[:, :, 2], cmap='gray')
52. plt.title("明度 (V)")
53. plt.axis('off')
55. plt.tight_layout()
56. plt.show()

复制代码

分离和合并RGB通道

我们可以使用NumPy来分离和合并RGB通道。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 分离RGB通道
11. r = img[:, :, 0]
12. g = img[:, :, 1]
13. b = img[:, :, 2]
15. # 创建只包含红色通道的图像
16. r_img = np.zeros_like(img)
17. r_img[:, :, 0] = r
19. # 创建只包含绿色通道的图像
20. g_img = np.zeros_like(img)
21. g_img[:, :, 1] = g
23. # 创建只包含蓝色通道的图像
24. b_img = np.zeros_like(img)
25. b_img[:, :, 2] = b
27. # 显示原始图像和各个通道
28. plt.figure(figsize=(15, 10))
30. plt.subplot(2, 2, 1)
31. plt.imshow(img)
32. plt.title("原始图像")
33. plt.axis('off')
35. plt.subplot(2, 2, 2)
36. plt.imshow(r_img)
37. plt.title("红色通道")
38. plt.axis('off')
40. plt.subplot(2, 2, 3)
41. plt.imshow(g_img)
42. plt.title("绿色通道")
43. plt.axis('off')
45. plt.subplot(2, 2, 4)
46. plt.imshow(b_img)
47. plt.title("蓝色通道")
48. plt.axis('off')
50. plt.tight_layout()
51. plt.show()

复制代码

图像滤波与增强

图像滤波和增强是图像处理中的重要操作，可以用于去噪、边缘检测、图像锐化等。

均值滤波

均值滤波是一种简单的线性滤波，用于图像平滑和去噪。它通过用邻域像素的平均值替换中心像素来实现。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import uniform_filter
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 应用均值滤波
18. # 使用3x3的滤波器
19. filtered_3x3 = uniform_filter(img_gray, size=3)
21. # 使用5x5的滤波器
22. filtered_5x5 = uniform_filter(img_gray, size=5)
24. # 使用7x7的滤波器
25. filtered_7x7 = uniform_filter(img_gray, size=7)
27. # 显示原始图像和滤波后的图像
28. plt.figure(figsize=(15, 10))
30. plt.subplot(2, 2, 1)
31. plt.imshow(img_gray, cmap='gray')
32. plt.title("原始灰度图像")
33. plt.axis('off')
35. plt.subplot(2, 2, 2)
36. plt.imshow(filtered_3x3, cmap='gray')
37. plt.title("3x3均值滤波")
38. plt.axis('off')
40. plt.subplot(2, 2, 3)
41. plt.imshow(filtered_5x5, cmap='gray')
42. plt.title("5x5均值滤波")
43. plt.axis('off')
45. plt.subplot(2, 2, 4)
46. plt.imshow(filtered_7x7, cmap='gray')
47. plt.title("7x7均值滤波")
48. plt.axis('off')
50. plt.tight_layout()
51. plt.show()

复制代码

高斯滤波

高斯滤波是一种更有效的平滑滤波器，它使用高斯函数作为权重，对中心像素给予更高的权重。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import gaussian_filter
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 应用高斯滤波
18. # 使用sigma=1
19. filtered_1 = gaussian_filter(img_gray, sigma=1)
21. # 使用sigma=2
22. filtered_2 = gaussian_filter(img_gray, sigma=2)
24. # 使用sigma=3
25. filtered_3 = gaussian_filter(img_gray, sigma=3)
27. # 显示原始图像和滤波后的图像
28. plt.figure(figsize=(15, 10))
30. plt.subplot(2, 2, 1)
31. plt.imshow(img_gray, cmap='gray')
32. plt.title("原始灰度图像")
33. plt.axis('off')
35. plt.subplot(2, 2, 2)
36. plt.imshow(filtered_1, cmap='gray')
37. plt.title("高斯滤波 (sigma=1)")
38. plt.axis('off')
40. plt.subplot(2, 2, 3)
41. plt.imshow(filtered_2, cmap='gray')
42. plt.title("高斯滤波 (sigma=2)")
43. plt.axis('off')
45. plt.subplot(2, 2, 4)
46. plt.imshow(filtered_3, cmap='gray')
47. plt.title("高斯滤波 (sigma=3)")
48. plt.axis('off')
50. plt.tight_layout()
51. plt.show()

复制代码

中值滤波

中值滤波是一种非线性滤波技术，对去除椒盐噪声特别有效。它通过用邻域像素的中值替换中心像素来实现。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import median_filter
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 添加椒盐噪声
18. noise_prob = 0.05  # 噪声概率
19. noisy_img = img_gray.copy()
20. rand_mask = np.random.random(img_gray.shape)
21. noisy_img[rand_mask < noise_prob/2] = 0  # 椒噪声
22. noisy_img[rand_mask > 1 - noise_prob/2] = 1  # 盐噪声
24. # 应用中值滤波
25. # 使用3x3的滤波器
26. filtered_3x3 = median_filter(noisy_img, size=3)
28. # 使用5x5的滤波器
29. filtered_5x5 = median_filter(noisy_img, size=5)
31. # 显示原始图像、噪声图像和滤波后的图像
32. plt.figure(figsize=(15, 10))
34. plt.subplot(2, 2, 1)
35. plt.imshow(img_gray, cmap='gray')
36. plt.title("原始灰度图像")
37. plt.axis('off')
39. plt.subplot(2, 2, 2)
40. plt.imshow(noisy_img, cmap='gray')
41. plt.title("添加椒盐噪声后的图像")
42. plt.axis('off')
44. plt.subplot(2, 2, 3)
45. plt.imshow(filtered_3x3, cmap='gray')
46. plt.title("3x3中值滤波")
47. plt.axis('off')
49. plt.subplot(2, 2, 4)
50. plt.imshow(filtered_5x5, cmap='gray')
51. plt.title("5x5中值滤波")
52. plt.axis('off')
54. plt.tight_layout()
55. plt.show()

复制代码

边缘检测

边缘检测是图像处理中的重要操作，用于识别图像中的边缘。我们可以使用Sobel算子来实现边缘检测。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import sobel
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 应用Sobel算子
18. # 水平方向边缘检测
19. edge_h = sobel(img_gray, axis=1)
21. # 垂直方向边缘检测
22. edge_v = sobel(img_gray, axis=0)
24. # 组合水平和垂直边缘
25. edge_combined = np.sqrt(edge_h**2 + edge_v**2)
27. # 显示原始图像和边缘检测结果
28. plt.figure(figsize=(15, 10))
30. plt.subplot(2, 2, 1)
31. plt.imshow(img_gray, cmap='gray')
32. plt.title("原始灰度图像")
33. plt.axis('off')
35. plt.subplot(2, 2, 2)
36. plt.imshow(edge_h, cmap='gray')
37. plt.title("水平边缘检测")
38. plt.axis('off')
40. plt.subplot(2, 2, 3)
41. plt.imshow(edge_v, cmap='gray')
42. plt.title("垂直边缘检测")
43. plt.axis('off')
45. plt.subplot(2, 2, 4)
46. plt.imshow(edge_combined, cmap='gray')
47. plt.title("组合边缘检测")
48. plt.axis('off')
50. plt.tight_layout()
51. plt.show()

复制代码

图像锐化

图像锐化可以增强图像的边缘和细节，使图像看起来更清晰。我们可以使用拉普拉斯算子来实现图像锐化。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import laplace
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 应用拉普拉斯算子
18. laplacian = laplace(img_gray)
20. # 图像锐化
21. # 锐化图像 = 原始图像 - 系数 * 拉普拉斯图像
22. alpha = 0.5  # 锐化系数
23. sharpened = img_gray - alpha * laplacian
25. # 确保值在0-1范围内
26. sharpened = np.clip(sharpened, 0, 1)
28. # 显示原始图像和锐化后的图像
29. plt.figure(figsize=(15, 5))
31. plt.subplot(1, 3, 1)
32. plt.imshow(img_gray, cmap='gray')
33. plt.title("原始灰度图像")
34. plt.axis('off')
36. plt.subplot(1, 3, 2)
37. plt.imshow(laplacian, cmap='gray')
38. plt.title("拉普拉斯图像")
39. plt.axis('off')
41. plt.subplot(1, 3, 3)
42. plt.imshow(sharpened, cmap='gray')
43. plt.title("锐化后的图像")
44. plt.axis('off')
46. plt.tight_layout()
47. plt.show()

复制代码

图像算术运算

图像算术运算包括图像的加法、减法、乘法和除法等操作。这些操作在图像处理中有广泛的应用，如图像混合、图像差异检测等。

图像加法

图像加法可以用于图像混合或增加图像亮度。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path1 = "example1.jpg"  # 替换为你的图像路径
8. image_path2 = "example2.jpg"  # 替换为你的图像路径
9. img1 = mpimg.imread(image_path1)
10. img2 = mpimg.imread(image_path2)
12. # 确保两个图像大小相同
13. if img1.shape != img2.shape:
14.     img2 = np.array(Image.fromarray(img2).resize((img1.shape[1], img1.shape[0])))
16. # 图像加法
17. # 方法1：简单相加（可能导致值超出范围）
18. added_simple = img1 + img2
20. # 方法2：加权相加（更常用）
21. alpha = 0.5  # 第一个图像的权重
22. beta = 0.5   # 第二个图像的权重
23. added_weighted = alpha * img1 + beta * img2
25. # 确保值在0-1范围内
26. added_weighted = np.clip(added_weighted, 0, 1)
28. # 显示原始图像和相加后的图像
29. plt.figure(figsize=(15, 5))
31. plt.subplot(1, 3, 1)
32. plt.imshow(img1)
33. plt.title("图像1")
34. plt.axis('off')
36. plt.subplot(1, 3, 2)
37. plt.imshow(img2)
38. plt.title("图像2")
39. plt.axis('off')
41. plt.subplot(1, 3, 3)
42. plt.imshow(added_weighted)
43. plt.title("加权相加后的图像")
44. plt.axis('off')
46. plt.tight_layout()
47. plt.show()

复制代码

图像减法

图像减法可以用于检测图像之间的差异或背景减除。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path1 = "example1.jpg"  # 替换为你的图像路径
8. image_path2 = "example2.jpg"  # 替换为你的图像路径
9. img1 = mpimg.imread(image_path1)
10. img2 = mpimg.imread(image_path2)
12. # 确保两个图像大小相同
13. if img1.shape != img2.shape:
14.     img2 = np.array(Image.fromarray(img2).resize((img1.shape[1], img1.shape[0])))
16. # 图像减法
17. subtracted = img1 - img2
19. # 显示绝对差异
20. absolute_diff = np.abs(img1 - img2)
22. # 显示原始图像和相减后的图像
23. plt.figure(figsize=(15, 10))
25. plt.subplot(2, 2, 1)
26. plt.imshow(img1)
27. plt.title("图像1")
28. plt.axis('off')
30. plt.subplot(2, 2, 2)
31. plt.imshow(img2)
32. plt.title("图像2")
33. plt.axis('off')
35. plt.subplot(2, 2, 3)
36. plt.imshow(subtracted)
37. plt.title("图像减法")
38. plt.axis('off')
40. plt.subplot(2, 2, 4)
41. plt.imshow(absolute_diff)
42. plt.title("绝对差异")
43. plt.axis('off')
45. plt.tight_layout()
46. plt.show()

复制代码

图像乘法

图像乘法可以用于调整图像对比度或应用掩码。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 转换为灰度图像
11. if len(img.shape) == 3:
12.     img_gray = np.mean(img, axis=2)
13. else:
14.     img_gray = img
16. # 创建一个掩码（例如，中心亮，周围暗）
17. height, width = img_gray.shape
18. y, x = np.ogrid[:height, :width]
19. center_y, center_x = height // 2, width // 2
21. # 创建径向渐变掩码
22. dist_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2)
23. max_dist = np.sqrt(center_x**2 + center_y**2)
24. mask = 1 - (dist_from_center / max_dist)
26. # 应用掩码
27. masked = img_gray * mask
29. # 调整对比度
30. contrast_factor = 1.5  # 大于1增加对比度，小于1降低对比度
31. mean = np.mean(img_gray)
32. adjusted = mean + contrast_factor * (img_gray - mean)
34. # 确保值在0-1范围内
35. adjusted = np.clip(adjusted, 0, 1)
37. # 显示原始图像和处理后的图像
38. plt.figure(figsize=(15, 10))
40. plt.subplot(2, 2, 1)
41. plt.imshow(img_gray, cmap='gray')
42. plt.title("原始灰度图像")
43. plt.axis('off')
45. plt.subplot(2, 2, 2)
46. plt.imshow(mask, cmap='gray')
47. plt.title("掩码")
48. plt.axis('off')
50. plt.subplot(2, 2, 3)
51. plt.imshow(masked, cmap='gray')
52. plt.title("应用掩码后的图像")
53. plt.axis('off')
55. plt.subplot(2, 2, 4)
56. plt.imshow(adjusted, cmap='gray')
57. plt.title("调整对比度后的图像")
58. plt.axis('off')
60. plt.tight_layout()
61. plt.show()

复制代码

图像除法

图像除法可以用于归一化或校正图像。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path = "example.jpg"  # 替换为你的图像路径
8. img = mpimg.imread(image_path)
10. # 转换为灰度图像
11. if len(img.shape) == 3:
12.     img_gray = np.mean(img, axis=2)
13. else:
14.     img_gray = img
16. # 创建一个背景图像（例如，模糊版本的原始图像）
17. from scipy.ndimage import gaussian_filter
18. background = gaussian_filter(img_gray, sigma=10)
20. # 图像除法（用于背景校正）
21. # 避免除以零
22. background = np.where(background < 0.01, 0.01, background)
23. corrected = img_gray / background
25. # 归一化到0-1范围
26. corrected = (corrected - np.min(corrected)) / (np.max(corrected) - np.min(corrected))
28. # 显示原始图像和处理后的图像
29. plt.figure(figsize=(15, 5))
31. plt.subplot(1, 3, 1)
32. plt.imshow(img_gray, cmap='gray')
33. plt.title("原始灰度图像")
34. plt.axis('off')
36. plt.subplot(1, 3, 2)
37. plt.imshow(background, cmap='gray')
38. plt.title("背景图像")
39. plt.axis('off')
41. plt.subplot(1, 3, 3)
42. plt.imshow(corrected, cmap='gray')
43. plt.title("背景校正后的图像")
44. plt.axis('off')
46. plt.tight_layout()
47. plt.show()

复制代码

实际案例

现在，让我们通过一些实际案例来综合运用前面学到的知识。

案例1：图像去噪

在这个案例中，我们将结合使用多种滤波技术来去除图像中的噪声。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import gaussian_filter, median_filter
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 添加高斯噪声
18. mean = 0
19. stddev = 0.1
20. gaussian_noise = np.random.normal(mean, stddev, img_gray.shape)
21. noisy_img_gaussian = img_gray + gaussian_noise
23. # 添加椒盐噪声
24. noise_prob = 0.05
25. noisy_img_salt_pepper = img_gray.copy()
26. rand_mask = np.random.random(img_gray.shape)
27. noisy_img_salt_pepper[rand_mask < noise_prob/2] = 0  # 椒噪声
28. noisy_img_salt_pepper[rand_mask > 1 - noise_prob/2] = 1  # 盐噪声
30. # 去噪处理
31. # 高斯噪声使用高斯滤波
32. denoised_gaussian = gaussian_filter(noisy_img_gaussian, sigma=1)
34. # 椒盐噪声使用中值滤波
35. denoised_salt_pepper = median_filter(noisy_img_salt_pepper, size=3)
37. # 确保值在0-1范围内
38. denoised_gaussian = np.clip(denoised_gaussian, 0, 1)
39. denoised_salt_pepper = np.clip(denoised_salt_pepper, 0, 1)
41. # 显示原始图像、噪声图像和去噪后的图像
42. plt.figure(figsize=(15, 10))
44. plt.subplot(2, 3, 1)
45. plt.imshow(img_gray, cmap='gray')
46. plt.title("原始灰度图像")
47. plt.axis('off')
49. plt.subplot(2, 3, 2)
50. plt.imshow(noisy_img_gaussian, cmap='gray')
51. plt.title("添加高斯噪声")
52. plt.axis('off')
54. plt.subplot(2, 3, 3)
55. plt.imshow(denoised_gaussian, cmap='gray')
56. plt.title("高斯滤波去噪")
57. plt.axis('off')
59. plt.subplot(2, 3, 4)
60. plt.imshow(img_gray, cmap='gray')
61. plt.title("原始灰度图像")
62. plt.axis('off')
64. plt.subplot(2, 3, 5)
65. plt.imshow(noisy_img_salt_pepper, cmap='gray')
66. plt.title("添加椒盐噪声")
67. plt.axis('off')
69. plt.subplot(2, 3, 6)
70. plt.imshow(denoised_salt_pepper, cmap='gray')
71. plt.title("中值滤波去噪")
72. plt.axis('off')
74. plt.tight_layout()
75. plt.show()

复制代码

案例2：图像增强

在这个案例中，我们将使用多种技术来增强图像的质量和视觉效果。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
5. from scipy.ndimage import laplace, gaussian_filter
7. # 加载图像
8. image_path = "example.jpg"  # 替换为你的图像路径
9. img = mpimg.imread(image_path)
11. # 转换为灰度图像
12. if len(img.shape) == 3:
13.     img_gray = np.mean(img, axis=2)
14. else:
15.     img_gray = img
17. # 1. 对比度增强
18. # 线性对比度拉伸
19. min_val = np.min(img_gray)
20. max_val = np.max(img_gray)
21. stretched = (img_gray - min_val) / (max_val - min_val)
23. # 2. 直方图均衡化
24. hist, bins = np.histogram(img_gray.flatten(), 256, [0, 1])
25. cdf = hist.cumsum()
26. cdf_normalized = cdf / cdf[-1]
27. equalized = np.interp(img_gray.flatten(), bins[:-1], cdf_normalized).reshape(img_gray.shape)
29. # 3. 锐化
30. # 使用拉普拉斯算子
31. laplacian = laplace(img_gray)
32. alpha = 0.5  # 锐化系数
33. sharpened = img_gray - alpha * laplacian
34. sharpened = np.clip(sharpened, 0, 1)
36. # 4. 边缘增强
37. # 提取边缘
38. edge_enhanced = img_gray + 0.5 * laplacian
39. edge_enhanced = np.clip(edge_enhanced, 0, 1)
41. # 显示原始图像和增强后的图像
42. plt.figure(figsize=(15, 10))
44. plt.subplot(2, 3, 1)
45. plt.imshow(img_gray, cmap='gray')
46. plt.title("原始灰度图像")
47. plt.axis('off')
49. plt.subplot(2, 3, 2)
50. plt.imshow(stretched, cmap='gray')
51. plt.title("对比度拉伸")
52. plt.axis('off')
54. plt.subplot(2, 3, 3)
55. plt.imshow(equalized, cmap='gray')
56. plt.title("直方图均衡化")
57. plt.axis('off')
59. plt.subplot(2, 3, 4)
60. plt.imshow(sharpened, cmap='gray')
61. plt.title("锐化")
62. plt.axis('off')
64. plt.subplot(2, 3, 5)
65. plt.imshow(edge_enhanced, cmap='gray')
66. plt.title("边缘增强")
67. plt.axis('off')
69. plt.tight_layout()
70. plt.show()

复制代码

案例3：图像拼接

在这个案例中，我们将学习如何将多张图像拼接成一张全景图。

2. import numpy as np
3. import matplotlib.pyplot as plt
4. import matplotlib.image as mpimg
6. # 加载图像
7. image_path1 = "left.jpg"  # 替换为你的图像路径
8. image_path2 = "right.jpg"  # 替换为你的图像路径
9. img1 = mpimg.imread(image_path1)
10. img2 = mpimg.imread(image_path2)
12. # 转换为灰度图像以简化处理
13. if len(img1.shape) == 3:
14.     img1_gray = np.mean(img1, axis=2)
15. else:
16.     img1_gray = img1
18. if len(img2.shape) == 3:
19.     img2_gray = np.mean(img2, axis=2)
20. else:
21.     img2_gray = img2
23. # 简单的图像拼接（水平拼接）
24. # 确保两个图像高度相同
25. if img1.shape[0] != img2.shape[0]:
26.     # 调整第二个图像的高度以匹配第一个图像
27.     from PIL import Image
28.     img2 = np.array(Image.fromarray(img2).resize((img2.shape[1], img1.shape[0])))
29.     img2_gray = np.mean(img2, axis=2) if len(img2.shape) == 3 else img2
31. # 水平拼接
32. panorama_simple = np.hstack((img1, img2))
34. # 更复杂的拼接（带重叠区域）
35. # 假设有20%的重叠区域
36. overlap_percent = 0.2
37. overlap_width = int(img1.shape[1] * overlap_percent)
39. # 创建全景图
40. panorama_width = img1.shape[1] + img2.shape[1] - overlap_width
41. panorama_height = img1.shape[0]
42. panorama = np.zeros((panorama_height, panorama_width, 3)) if len(img1.shape) == 3 else np.zeros((panorama_height, panorama_width))
44. # 放置第一张图像
45. panorama[:, :img1.shape[1]] = img1
47. # 创建渐变掩码用于重叠区域
48. mask = np.linspace(1, 0, overlap_width)
49. if len(img1.shape) == 3:
50.     mask_3d = np.tile(mask[:, np.newaxis], (1, 3, 1)).transpose(2, 0, 1)
51. else:
52.     mask_3d = mask[:, np.newaxis]
54. # 放置第二张图像，重叠区域使用渐变混合
55. panorama[:, img1.shape[1]-overlap_width:] = (
56.     img1[:, -overlap_width:] * mask_3d +
57.     img2[:, :overlap_width] * (1 - mask_3d)
58. )
59. panorama[:, img1.shape[1]:] = img2[:, overlap_width:]
61. # 显示原始图像和拼接后的图像
62. plt.figure(figsize=(15, 5))
64. plt.subplot(1, 3, 1)
65. plt.imshow(img1)
66. plt.title("图像1")
67. plt.axis('off')
69. plt.subplot(1, 3, 2)
70. plt.imshow(img2)
71. plt.title("图像2")
72. plt.axis('off')
74. plt.subplot(1, 3, 3)
75. plt.imshow(panorama)
76. plt.title("拼接后的全景图")
77. plt.axis('off')
79. plt.tight_layout()
80. plt.show()

复制代码

总结与进阶学习资源

通过本文的学习，我们已经掌握了使用NumPy进行图像处理的基础操作，包括图像的加载与显示、基本图像操作、颜色空间转换、图像滤波与增强、图像算术运算等内容。这些基础知识为我们后续学习更高级的图像处理技术打下了坚实的基础。

总结要点

1. NumPy数组与图像：图像在NumPy中表示为多维数组，灰度图像是二维数组，彩色图像是三维数组。
2. 图像基本操作：包括裁剪、旋转、缩放和翻转等，这些操作可以通过NumPy的切片和变换函数实现。
3. 颜色空间转换：包括RGB转灰度、RGB转HSV等，这些转换在图像处理中非常常见。
4. 图像滤波与增强：包括均值滤波、高斯滤波、中值滤波、边缘检测和图像锐化等，这些操作可以用于去噪、特征提取和图像增强。
5. 图像算术运算：包括图像的加法、减法、乘法和除法，这些操作在图像混合、差异检测和对比度调整等方面有广泛应用。

NumPy数组与图像：图像在NumPy中表示为多维数组，灰度图像是二维数组，彩色图像是三维数组。

图像基本操作：包括裁剪、旋转、缩放和翻转等，这些操作可以通过NumPy的切片和变换函数实现。

颜色空间转换：包括RGB转灰度、RGB转HSV等，这些转换在图像处理中非常常见。

图像滤波与增强：包括均值滤波、高斯滤波、中值滤波、边缘检测和图像锐化等，这些操作可以用于去噪、特征提取和图像增强。

图像算术运算：包括图像的加法、减法、乘法和除法，这些操作在图像混合、差异检测和对比度调整等方面有广泛应用。

进阶学习资源

如果你想进一步学习图像处理，以下资源可能会有所帮助：

1. OpenCV：OpenCV是一个开源的计算机视觉库，提供了丰富的图像处理和计算机视觉功能。它是NumPy图像处理的自然延伸。
2. scikit-image：scikit-image是一个基于NumPy的图像处理库，提供了许多高级图像处理算法。
3. PIL/Pillow：PIL（Python Imaging Library）或其分支Pillow是Python中常用的图像处理库，提供了图像I/O和基本的图像处理功能。
4. 深度学习框架：如TensorFlow、PyTorch等，它们提供了强大的图像处理和计算机视觉功能，特别是在深度学习领域。
5. 在线课程和教程：Coursera上的”图像处理基础”课程Udemy上的”Python图像处理：从入门到精通”YouTube上的图像处理教程
6. Coursera上的”图像处理基础”课程
7. Udemy上的”Python图像处理：从入门到精通”
8. YouTube上的图像处理教程
9. 书籍：《数字图像处理》（Digital Image Processing）by Rafael C. Gonzalez and Richard E. Woods《Python计算机视觉编程》（Programming Computer Vision with Python）by Jan Erik Solem
10. 《数字图像处理》（Digital Image Processing）by Rafael C. Gonzalez and Richard E. Woods
11. 《Python计算机视觉编程》（Programming Computer Vision with Python）by Jan Erik Solem

OpenCV：OpenCV是一个开源的计算机视觉库，提供了丰富的图像处理和计算机视觉功能。它是NumPy图像处理的自然延伸。

scikit-image：scikit-image是一个基于NumPy的图像处理库，提供了许多高级图像处理算法。

PIL/Pillow：PIL（Python Imaging Library）或其分支Pillow是Python中常用的图像处理库，提供了图像I/O和基本的图像处理功能。

深度学习框架：如TensorFlow、PyTorch等，它们提供了强大的图像处理和计算机视觉功能，特别是在深度学习领域。

在线课程和教程：

• Coursera上的”图像处理基础”课程
• Udemy上的”Python图像处理：从入门到精通”
• YouTube上的图像处理教程

书籍：

• 《数字图像处理》（Digital Image Processing）by Rafael C. Gonzalez and Richard E. Woods
• 《Python计算机视觉编程》（Programming Computer Vision with Python）by Jan Erik Solem

通过不断学习和实践，你将能够掌握更多高级的图像处理技术，并将其应用到实际项目中。祝你在图像处理的学习之旅中取得成功！