简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：为庆祝网站一周年，将在5.1日与5.2日开放注册，具体信息请见后续详细公告
04-22 00:04
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

numpy输出图片完整教程深入浅出讲解如何使用Python科学计算库处理图像数据从数组定义到可视化输出包括matplotlib集成和实际代码示例助您快速上手

威震华夏关云长
SunJu_FaceMall

3万

主题

1158

科技点

3万

积分

白金月票

碾压王

积分
32796

立华奏
发表于 2025-10-1 22:50:10 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

NumPy是Python科学计算的核心库，提供了高性能的多维数组对象以及用于处理这些数组的工具。在图像处理领域，NumPy扮演着至关重要的角色，因为图像本质上就是多维数组（矩阵）。本教程将深入浅出地介绍如何使用NumPy处理图像数据，从基础的数组定义到复杂的图像操作，再到使用Matplotlib进行可视化输出。

NumPy基础

安装NumPy

在开始之前，确保已安装NumPy库。如果尚未安装，可以通过以下命令安装：
  2. pip install numpy
复制代码

创建NumPy数组

NumPy的核心是ndarray对象，它是一个快速、灵活的大型数据集容器。让我们从创建基本的数组开始：
  2. import numpy as np
  4. # 创建一维数组
  5. arr1d = np.array([1, 2, 3, 4, 5])
  6. print("一维数组:")
  7. print(arr1d)
  9. # 创建二维数组
  10. arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  11. print("\n二维数组:")
  12. print(arr2d)
  14. # 创建特定数组
  15. zeros = np.zeros((3, 3))  # 全零数组
  16. ones = np.ones((2, 4))    # 全一数组
  17. random = np.random.rand(3, 3)  # 随机数组
  19. print("\n全零数组:")
  20. print(zeros)
  21. print("\n全一数组:")
  22. print(ones)
  23. print("\n随机数组:")
  24. print(random)
复制代码

数组属性和操作

了解数组的基本属性对于图像处理至关重要：
  2. # 获取数组属性
  3. arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
  4. print("数组形状:", arr.shape)  # 数组维度
  5. print("数组大小:", arr.size)   # 元素总数
  6. print("数组类型:", arr.dtype)  # 数据类型
  8. # 改变数组形状
  9. reshaped = arr.reshape(1, 9)  # 将3x3数组变为1x9数组
  10. print("\n重塑后的数组:")
  11. print(reshaped)
  13. # 数组切片
  14. print("\n第一行:", arr[0])     # 获取第一行
  15. print("\n第一列:", arr[:, 0])  # 获取第一列
  16. print("\n子数组:")
  17. print(arr[0:2, 0:2])          # 获取左上角的2x2子数组
复制代码

图像数据与NumPy数组的关系

在计算机中，图像可以表示为多维数组。对于灰度图像，它是一个二维数组，其中每个元素代表一个像素的亮度值。对于彩色图像，它通常是一个三维数组，其中前两个维度表示空间位置（高度和宽度），第三个维度表示颜色通道（通常是红色、绿色和蓝色，即RGB）。

让我们创建一个简单的灰度图像和彩色图像：
  2. # 创建一个简单的灰度图像（8x8像素）
  3. gray_image = np.zeros((8, 8), dtype=np.uint8)
  4. gray_image[2:6, 2:6] = 255  # 在中心创建一个白色方块
  6. # 创建一个简单的彩色图像（8x8像素，RGB）
  7. color_image = np.zeros((8, 8, 3), dtype=np.uint8)
  8. color_image[2:6, 2:6, 0] = 255  # 红色通道
  9. color_image[2:6, 2:6, 1] = 0    # 绿色通道
  10. color_image[2:6, 2:6, 2] = 0    # 蓝色通道
  12. print("灰度图像数组:")
  13. print(gray_image)
  14. print("\n彩色图像数组形状:", color_image.shape)
复制代码

使用NumPy读取和处理图像

虽然NumPy本身不提供直接读取图像文件的功能，但我们可以结合其他库（如PIL或OpenCV）来读取图像，并将其转换为NumPy数组进行处理。

使用PIL读取图像

首先，确保安装PIL库：
  2. pip install pillow
复制代码

然后，使用以下代码读取图像：
  2. from PIL import Image
  3. import numpy as np
  5. # 读取图像
  6. image_path = "example.jpg"  # 替换为你的图像路径
  7. img = Image.open(image_path)
  9. # 将PIL图像转换为NumPy数组
  10. img_array = np.array(img)
  12. print("图像数组形状:", img_array.shape)
  13. print("图像数据类型:", img_array.dtype)
复制代码

使用OpenCV读取图像

OpenCV是另一个流行的图像处理库，它直接将图像作为NumPy数组返回：
  2. pip install opencv-python
复制代码
  2. import cv2
  3. import numpy as np
  5. # 读取图像
  6. image_path = "example.jpg"  # 替换为你的图像路径
  7. img_array = cv2.imread(image_path)
  9. print("图像数组形状:", img_array.shape)
  10. print("图像数据类型:", img_array.dtype)
  12. # 注意：OpenCV默认以BGR顺序读取彩色图像，而不是RGB
  13. # 如果需要转换为RGB顺序：
  14. img_rgb = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
复制代码

图像基本操作

裁剪图像

裁剪图像实际上是数组切片操作：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 裁剪图像 (y1:y2, x1:x2)
  11. height, width = img_array.shape[:2]
  12. cropped = img_array[int(height*0.2):int(height*0.8), int(width*0.2):int(width*0.8)]
  14. # 显示结果
  15. plt.figure(figsize=(12, 6))
  16. plt.subplot(1, 2, 1)
  17. plt.imshow(img_array)
  18. plt.title("原始图像")
  19. plt.subplot(1, 2, 2)
  20. plt.imshow(cropped)
  21. plt.title("裁剪后的图像")
  22. plt.show()
复制代码

调整图像大小

调整图像大小可以使用NumPy的插值方法，但更常见的是使用PIL或OpenCV提供的函数：
  2. from PIL import Image
  3. import numpy as np
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 使用PIL调整大小
  11. resized_pil = img.resize((img_array.shape[1]//2, img_array.shape[0]//2), Image.LANCZOS)
  12. resized_array = np.array(resized_pil)
  14. # 显示结果
  15. plt.figure(figsize=(12, 6))
  16. plt.subplot(1, 2, 1)
  17. plt.imshow(img_array)
  18. plt.title("原始图像")
  19. plt.subplot(1, 2, 2)
  20. plt.imshow(resized_array)
  21. plt.title("调整大小后的图像")
  22. plt.show()
复制代码

旋转图像

旋转图像可以使用NumPy的矩阵操作，但更简单的方法是使用PIL或OpenCV：
  2. from PIL import Image
  3. import numpy as np
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 使用PIL旋转图像
  11. rotated_pil = img.rotate(45)  # 旋转45度
  12. rotated_array = np.array(rotated_pil)
  14. # 显示结果
  15. plt.figure(figsize=(12, 6))
  16. plt.subplot(1, 2, 1)
  17. plt.imshow(img_array)
  18. plt.title("原始图像")
  19. plt.subplot(1, 2, 2)
  20. plt.imshow(rotated_array)
  21. plt.title("旋转后的图像")
  22. plt.show()
复制代码

翻转图像

翻转图像可以使用NumPy的切片操作：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 水平翻转
  11. flipped_h = np.fliplr(img_array)
  13. # 垂直翻转
  14. flipped_v = np.flipud(img_array)
  16. # 显示结果
  17. plt.figure(figsize=(15, 5))
  18. plt.subplot(1, 3, 1)
  19. plt.imshow(img_array)
  20. plt.title("原始图像")
  21. plt.subplot(1, 3, 2)
  22. plt.imshow(flipped_h)
  23. plt.title("水平翻转")
  24. plt.subplot(1, 3, 3)
  25. plt.imshow(flipped_v)
  26. plt.title("垂直翻转")
  27. plt.show()
复制代码

图像滤波和增强

灰度转换

将彩色图像转换为灰度图像：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 转换为灰度图像
  11. if len(img_array.shape) == 3:  # 如果是彩色图像
  12.     # 使用加权平均法转换
  13.     gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140])
  14.     gray = gray.astype(np.uint8)
  15. else:
  16.     gray = img_array  # 已经是灰度图像
  18. # 显示结果
  19. plt.figure(figsize=(12, 6))
  20. plt.subplot(1, 2, 1)
  21. plt.imshow(img_array)
  22. plt.title("原始图像")
  23. plt.subplot(1, 2, 2)
  24. plt.imshow(gray, cmap='gray')
  25. plt.title("灰度图像")
  26. plt.show()
复制代码

亮度调整

调整图像亮度：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 增加亮度
  11. brightness_factor = 1.5  # 亮度因子
  12. brightened = np.clip(img_array * brightness_factor, 0, 255).astype(np.uint8)
  14. # 降低亮度
  15. darkened = np.clip(img_array / brightness_factor, 0, 255).astype(np.uint8)
  17. # 显示结果
  18. plt.figure(figsize=(15, 5))
  19. plt.subplot(1, 3, 1)
  20. plt.imshow(img_array)
  21. plt.title("原始图像")
  22. plt.subplot(1, 3, 2)
  23. plt.imshow(brightened)
  24. plt.title("增加亮度")
  25. plt.subplot(1, 3, 3)
  26. plt.imshow(darkened)
  27. plt.title("降低亮度")
  28. plt.show()
复制代码

对比度调整

调整图像对比度：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 增加对比度
  11. contrast_factor = 1.5  # 对比度因子
  12. mean = np.mean(img_array)
  13. increased_contrast = np.clip((img_array - mean) * contrast_factor + mean, 0, 255).astype(np.uint8)
  15. # 降低对比度
  16. decreased_contrast = np.clip((img_array - mean) / contrast_factor + mean, 0, 255).astype(np.uint8)
  18. # 显示结果
  19. plt.figure(figsize=(15, 5))
  20. plt.subplot(1, 3, 1)
  21. plt.imshow(img_array)
  22. plt.title("原始图像")
  23. plt.subplot(1, 3, 2)
  24. plt.imshow(increased_contrast)
  25. plt.title("增加对比度")
  26. plt.subplot(1, 3, 3)
  27. plt.imshow(decreased_contrast)
  28. plt.title("降低对比度")
  29. plt.show()
复制代码

图像平滑（模糊）

图像平滑可以使用卷积操作实现：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  5. from scipy import ndimage
  7. # 读取图像
  8. img = Image.open("example.jpg")
  9. img_array = np.array(img)
  11. # 转换为灰度图像以便处理
  12. if len(img_array.shape) == 3:
  13.     gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  14. else:
  15.     gray = img_array
  17. # 均值滤波
  18. smoothed_mean = ndimage.uniform_filter(gray, size=5)
  20. # 高斯滤波
  21. smoothed_gaussian = ndimage.gaussian_filter(gray, sigma=2)
  23. # 显示结果
  24. plt.figure(figsize=(15, 5))
  25. plt.subplot(1, 3, 1)
  26. plt.imshow(gray, cmap='gray')
  27. plt.title("原始图像")
  28. plt.subplot(1, 3, 2)
  29. plt.imshow(smoothed_mean, cmap='gray')
  30. plt.title("均值滤波")
  31. plt.subplot(1, 3, 3)
  32. plt.imshow(smoothed_gaussian, cmap='gray')
  33. plt.title("高斯滤波")
  34. plt.show()
复制代码

边缘检测

边缘检测是图像处理中的常见任务，可以使用Sobel算子实现：
  2. import numpy as np
  3. from PIL import Image
  4. import matplotlib.pyplot as plt
  5. from scipy import ndimage
  7. # 读取图像
  8. img = Image.open("example.jpg")
  9. img_array = np.array(img)
  11. # 转换为灰度图像
  12. if len(img_array.shape) == 3:
  13.     gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  14. else:
  15.     gray = img_array
  17. # Sobel边缘检测
  18. sobel_h = ndimage.sobel(gray, axis=0)  # 水平边缘
  19. sobel_v = ndimage.sobel(gray, axis=1)  # 垂直边缘
  20. sobel = np.sqrt(sobel_h**2 + sobel_v**2)  # 合并边缘
  22. # 显示结果
  23. plt.figure(figsize=(15, 5))
  24. plt.subplot(1, 3, 1)
  25. plt.imshow(gray, cmap='gray')
  26. plt.title("原始图像")
  27. plt.subplot(1, 3, 2)
  28. plt.imshow(sobel_h, cmap='gray')
  29. plt.title("水平边缘")
  30. plt.subplot(1, 3, 3)
  31. plt.imshow(sobel, cmap='gray')
  32. plt.title("合并边缘")
  33. plt.show()
复制代码

使用Matplotlib进行图像可视化

Matplotlib是Python中最常用的绘图库，它可以很好地与NumPy集成，用于图像可视化。

安装Matplotlib

如果尚未安装Matplotlib，可以通过以下命令安装：
  2. pip install matplotlib
复制代码

基本图像显示

使用Matplotlib显示图像：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 显示图像
  11. plt.figure(figsize=(8, 6))
  12. plt.imshow(img_array)
  13. plt.title("图像显示示例")
  14. plt.axis('off')  # 关闭坐标轴
  15. plt.show()
复制代码

显示多个图像

在一个窗口中显示多个图像：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 创建不同的图像处理版本
  11. gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  12. flipped = np.fliplr(img_array)
  13. cropped = img_array[int(img_array.shape[0]*0.2):int(img_array.shape[0]*0.8),
  14.                    int(img_array.shape[1]*0.2):int(img_array.shape[1]*0.8)]
  16. # 创建2x2的子图
  17. plt.figure(figsize=(12, 10))
  19. # 原始图像
  20. plt.subplot(2, 2, 1)
  21. plt.imshow(img_array)
  22. plt.title("原始图像")
  23. plt.axis('off')
  25. # 灰度图像
  26. plt.subplot(2, 2, 2)
  27. plt.imshow(gray, cmap='gray')
  28. plt.title("灰度图像")
  29. plt.axis('off')
  31. # 翻转图像
  32. plt.subplot(2, 2, 3)
  33. plt.imshow(flipped)
  34. plt.title("翻转图像")
  35. plt.axis('off')
  37. # 裁剪图像
  38. plt.subplot(2, 2, 4)
  39. plt.imshow(cropped)
  40. plt.title("裁剪图像")
  41. plt.axis('off')
  43. plt.tight_layout()
  44. plt.show()
复制代码

直方图可视化

图像直方图是图像处理中的重要工具，可以显示图像中像素值的分布：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 转换为灰度图像
  11. if len(img_array.shape) == 3:
  12.     gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  13. else:
  14.     gray = img_array
  16. # 显示图像和直方图
  17. plt.figure(figsize=(12, 6))
  19. # 显示图像
  20. plt.subplot(1, 2, 1)
  21. plt.imshow(gray, cmap='gray')
  22. plt.title("灰度图像")
  23. plt.axis('off')
  25. # 显示直方图
  26. plt.subplot(1, 2, 2)
  27. plt.hist(gray.ravel(), bins=256, range=(0, 256), density=True, color='black', alpha=0.7)
  28. plt.title("像素值直方图")
  29. plt.xlabel("像素值")
  30. plt.ylabel("频率")
  31. plt.xlim(0, 256)
  33. plt.tight_layout()
  34. plt.show()
复制代码

彩色图像的直方图

对于彩色图像，可以分别显示每个颜色通道的直方图：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 确保是彩色图像
  11. if len(img_array.shape) == 3:
  12.     # 分离颜色通道
  13.     r = img_array[:, :, 0]
  14.     g = img_array[:, :, 1]
  15.     b = img_array[:, :, 2]
  16.    
  17.     # 显示图像和直方图
  18.     plt.figure(figsize=(15, 5))
  19.    
  20.     # 显示图像
  21.     plt.subplot(1, 2, 1)
  22.     plt.imshow(img_array)
  23.     plt.title("彩色图像")
  24.     plt.axis('off')
  25.    
  26.     # 显示直方图
  27.     plt.subplot(1, 2, 2)
  28.     plt.hist(r.ravel(), bins=256, range=(0, 256), density=True, color='red', alpha=0.5, label='Red')
  29.     plt.hist(g.ravel(), bins=256, range=(0, 256), density=True, color='green', alpha=0.5, label='Green')
  30.     plt.hist(b.ravel(), bins=256, range=(0, 256), density=True, color='blue', alpha=0.5, label='Blue')
  31.     plt.title("颜色通道直方图")
  32.     plt.xlabel("像素值")
  33.     plt.ylabel("频率")
  34.     plt.xlim(0, 256)
  35.     plt.legend()
  36.    
  37.     plt.tight_layout()
  38.     plt.show()
  39. else:
  40.     print("图像不是彩色图像")
复制代码

保存图像

使用Matplotlib保存图像：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 创建图形
  11. plt.figure(figsize=(8, 6))
  12. plt.imshow(img_array)
  13. plt.title("保存图像示例")
  14. plt.axis('off')
  16. # 保存图像
  17. plt.savefig("saved_image.png", dpi=300, bbox_inches='tight')
  18. plt.close()  # 关闭图形，避免显示
复制代码

实际应用案例

图像拼接

将多张图像拼接成一张大图：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取多张图像
  7. image_paths = ["image1.jpg", "image2.jpg", "image3.jpg", "image4.jpg"]  # 替换为实际路径
  8. images = [np.array(Image.open(path)) for path in image_paths]
  10. # 确保所有图像具有相同的高度
  11. min_height = min(img.shape[0] for img in images)
  12. resized_images = [img[:min_height, :] for img in images]
  14. # 水平拼接图像
  15. stitched_h = np.hstack(resized_images)
  17. # 垂直拼接图像
  18. min_width = min(img.shape[1] for img in images)
  19. resized_images_v = [img[:, :min_width] for img in images]
  20. stitched_v = np.vstack(resized_images_v)
  22. # 显示结果
  23. plt.figure(figsize=(15, 10))
  25. plt.subplot(2, 1, 1)
  26. plt.imshow(stitched_h)
  27. plt.title("水平拼接")
  28. plt.axis('off')
  30. plt.subplot(2, 1, 2)
  31. plt.imshow(stitched_v)
  32. plt.title("垂直拼接")
  33. plt.axis('off')
  35. plt.tight_layout()
  36. plt.show()
复制代码

批量处理图像

批量处理文件夹中的所有图像：
  2. import os
  3. import numpy as np
  4. from PIL import Image
  5. import matplotlib.pyplot as plt
  7. # 设置输入和输出文件夹
  8. input_folder = "input_images"  # 替换为实际路径
  9. output_folder = "output_images"  # 替换为实际路径
  11. # 创建输出文件夹（如果不存在）
  12. os.makedirs(output_folder, exist_ok=True)
  14. # 处理文件夹中的所有图像
  15. for filename in os.listdir(input_folder):
  16.     if filename.endswith(('.jpg', '.jpeg', '.png')):
  17.         # 读取图像
  18.         input_path = os.path.join(input_folder, filename)
  19.         img = Image.open(input_path)
  20.         img_array = np.array(img)
  21.         
  22.         # 应用图像处理（例如转换为灰度并调整大小）
  23.         if len(img_array.shape) == 3:
  24.             gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  25.         else:
  26.             gray = img_array
  27.             
  28.         # 调整大小
  29.         resized = Image.fromarray(gray).resize((gray.shape[1]//2, gray.shape[0]//2), Image.LANCZOS)
  30.         resized_array = np.array(resized)
  31.         
  32.         # 保存处理后的图像
  33.         output_path = os.path.join(output_folder, f"processed_{filename}")
  34.         Image.fromarray(resized_array).save(output_path)
  35.         
  36.         print(f"已处理并保存: {filename}")
  38. print("批量处理完成!")
复制代码

图像分割

简单的阈值分割示例：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  6. # 读取图像
  7. img = Image.open("example.jpg")
  8. img_array = np.array(img)
  10. # 转换为灰度图像
  11. if len(img_array.shape) == 3:
  12.     gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  13. else:
  14.     gray = img_array
  16. # 应用阈值分割
  17. threshold = 128  # 阈值
  18. binary = gray > threshold
  20. # 显示结果
  21. plt.figure(figsize=(15, 5))
  23. plt.subplot(1, 3, 1)
  24. plt.imshow(gray, cmap='gray')
  25. plt.title("原始灰度图像")
  26. plt.axis('off')
  28. plt.subplot(1, 3, 2)
  29. plt.imshow(binary, cmap='gray')
  30. plt.title(f"阈值分割 (阈值={threshold})")
  31. plt.axis('off')
  33. plt.subplot(1, 3, 3)
  34. plt.hist(gray.ravel(), bins=256, range=(0, 256), density=True, color='black', alpha=0.7)
  35. plt.axvline(x=threshold, color='red', linestyle='--')
  36. plt.title("直方图与阈值")
  37. plt.xlabel("像素值")
  38. plt.ylabel("频率")
  39. plt.xlim(0, 256)
  41. plt.tight_layout()
  42. plt.show()
复制代码

图像特征提取

提取图像的基本特征：
  2. import numpy as np
  3. import matplotlib.pyplot as plt
  4. from PIL import Image
  5. from scipy import ndimage
  7. # 读取图像
  8. img = Image.open("example.jpg")
  9. img_array = np.array(img)
  11. # 转换为灰度图像
  12. if len(img_array.shape) == 3:
  13.     gray = np.dot(img_array[...,:3], [0.2989, 0.5870, 0.1140]).astype(np.uint8)
  14. else:
  15.     gray = img_array
  17. # 计算基本特征
  18. mean_brightness = np.mean(gray)
  19. std_brightness = np.std(gray)
  20. min_brightness = np.min(gray)
  21. max_brightness = np.max(gray)
  23. # 计算梯度（边缘强度）
  24. grad_x = ndimage.sobel(gray, axis=0)
  25. grad_y = ndimage.sobel(gray, axis=1)
  26. gradient_magnitude = np.sqrt(grad_x**2 + grad_y**2)
  27. mean_gradient = np.mean(gradient_magnitude)
  29. # 显示结果
  30. plt.figure(figsize=(15, 5))
  32. plt.subplot(1, 3, 1)
  33. plt.imshow(gray, cmap='gray')
  34. plt.title("原始图像")
  35. plt.axis('off')
  37. plt.subplot(1, 3, 2)
  38. plt.imshow(gradient_magnitude, cmap='gray')
  39. plt.title("梯度幅度")
  40. plt.axis('off')
  42. plt.subplot(1, 3, 3)
  43. plt.text(0.1, 0.8, f"平均亮度: {mean_brightness:.2f}", transform=plt.gca().transAxes)
  44. plt.text(0.1, 0.7, f"亮度标准差: {std_brightness:.2f}", transform=plt.gca().transAxes)
  45. plt.text(0.1, 0.6, f"最小亮度: {min_brightness}", transform=plt.gca().transAxes)
  46. plt.text(0.1, 0.5, f"最大亮度: {max_brightness}", transform=plt.gca().transAxes)
  47. plt.text(0.1, 0.4, f"平均梯度: {mean_gradient:.2f}", transform=plt.gca().transAxes)
  48. plt.title("图像特征")
  49. plt.axis('off')
  51. plt.tight_layout()
  52. plt.show()
复制代码

总结与资源推荐

本教程详细介绍了如何使用NumPy处理图像数据，从基础的数组操作到复杂的图像处理技术。我们学习了：

1. NumPy基础知识和数组操作
2. 图像数据与NumPy数组的关系
3. 如何读取和处理图像
4. 图像的基本操作（裁剪、缩放、旋转、翻转）
5. 图像滤波和增强技术
6. 使用Matplotlib进行图像可视化
7. 实际应用案例

NumPy与图像处理的结合为科学计算和计算机视觉任务提供了强大的工具。通过掌握这些技术，您可以进一步探索更高级的图像处理和计算机视觉领域。

推荐资源

1. NumPy官方文档:https://numpy.org/doc/stable/
2. Matplotlib官方文档:https://matplotlib.org/stable/contents.html
3. Python图像处理手册:https://github.com/ActiveState/python-image-processing
4. OpenCV-Python教程:https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html
5. Scikit-image文档:https://scikit-image.org/docs/stable/

希望本教程能帮助您快速上手使用NumPy处理图像数据。随着您对这些技术的掌握，您将能够解决更复杂的图像处理问题，并在计算机视觉领域取得更大的成就。
高性能, 扮演着, 图像处理
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

关闭

站长推荐上一条 /1 下一条

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
Telegram

Telegram

Discord

Discord

Tencent QQ

Tencent QQ

手机版|联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.

>