OpenCV

2024-09-23  本文已影响0人  阿凡提说AI

OpenCV（Open Source Computer Vision Library）是一个强大的开源计算机视觉和机器学习软件库。它提供了丰富的工具和功能，广泛应用于图像处理、视频分析、视图重建、物体识别、面部识别等领域。以下是OpenCV的一些关键方面和常见应用。

1. OpenCV的基本概念

2. 主要功能

图像处理:

特征检测与匹配:

物体识别与跟踪:

视频处理:

机器学习:

3. 安装与使用

安装:

简单示例:
以下是一个使用OpenCV读取和显示图像的基本示例：

import cv2

# 读取图像
image = cv2.imread('example.jpg')

# 显示图像
cv2.imshow('Image', image)

# 等待按键并关闭窗口
cv2.waitKey(0)
cv2.destroyAllWindows()

4. 常见应用场景

5. 资源与学习

6.cv2.imread()

cv2.imread 是 OpenCV 库中用于读取图像的一个函数。它非常重要，因为它是任何图像处理或计算机视觉项目的起点。让我们详细了解这个 API 的功能、参数、返回值以及一些示例。

函数签名

cv2.imread(filename, flags=cv2.IMREAD_COLOR)

参数

例子：

import cv2

# 读取图像（彩色）
image_color = cv2.imread('image.jpg', cv2.IMREAD_COLOR)

# 读取图像（灰度）
image_gray = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

# 读取图像（保留原始内容，包括透明度）
image_unchanged = cv2.imread('image.png', cv2.IMREAD_UNCHANGED)

返回值

错误处理

在调用 cv2.imread 之后，建议检查返回值，以确保图像成功加载。使用如下方法：

image = cv2.imread('image.jpg')
if image is None:
    print("Error: Could not open or find the image.")
else:
    print("Image loaded successfully!")

使用示例

以下示例将展示如何使用 cv2.imread 来读取并显示图像：

import cv2

# 读取图像
image = cv2.imread('image.jpg', cv2.IMREAD_COLOR)

# 检查图像是否加载成功
if image is None:
    print("Error: Could not open or find the image.")
else:
    # 显示图像
    cv2.imshow('Loaded Image', image)

    # 等待按键并关闭窗口
    cv2.waitKey(0)
    cv2.destroyAllWindows()

常见问题

  1. 文件路径问题: 确保文件路径正确，尤其在使用相对路径时。
  2. 图像格式: cv2.imread 支持多种图像格式，但如果图像受损或格式不支持，可能会返回 None。
  3. 透明图像: 如果想读取 PNG 等带透明通道的图像，使用 cv2.IMREAD_UNCHANGED。

总结

cv2.imread 是 OpenCV 中极为重要的一个函数，提供了灵活的方式来读取各种格式的图像。了解其工作方式和参数设置有助于在图像处理和计算机视觉项目中有效使用图像数据。

7.cv2.imshow()

函数签名

cv2.imshow(winname, mat)

参数

使用步骤

  1. 读取图像: 使用 cv2.imread 读取图像。
  2. 显示图像: 使用 cv2.imshow 显示图像。
  3. 等待按键: 使用 cv2.waitKey 等待用户按下任意键。
  4. 关闭窗口: 使用 cv2.destroyAllWindows 关闭所有创建的窗口。

示例

下面是一个完整的示例，演示如何使用 cv2.imshow 来显示一张图像：

import cv2

# 读取图像
image = cv2.imread('image.jpg', cv2.IMREAD_COLOR)

# 检查图像是否加载成功
if image is None:
    print("Error: Could not open or find the image.")
else:
    # 使用 cv2.imshow 显示图像
    cv2.imshow('Loaded Image', image)

    # 等待按键（0 表示无限等待）
    cv2.waitKey(0)

    # 关闭所有窗口
    cv2.destroyAllWindows()#这里也可以使用cv2.destoryWindow("Loaded Image")

注意事项

8.cv2.waitKey()

cv2.waitKey() 是 OpenCV 中用于等待用户按键的函数。这个函数在图像显示程序中非常重要，通常与 cv2.imshow() 一起使用，来控制窗口的响应与关闭。

函数签名

cv2.waitKey(delay)

参数

返回值

使用示例

以下是使用 cv2.imshow() 和 cv2.waitKey() 的完整示例：

import cv2

# 读取图像
image = cv2.imread('image.jpg', cv2.IMREAD_COLOR)

# 检查图像是否加载成功
if image is None:
    print("Error: Could not open or find the image.")
else:
    # 显示图像
    cv2.imshow('Loaded Image', image)

    # 无限等待用户按键
    key = cv2.waitKey(0)

    # 可以根据返回值执行其他操作
    if key == ord('s'):  # 如果用户按下 's' 键
        print("You pressed 's'!")
    else:
        print("You pressed a different key.")

    # 关闭所有窗口
    cv2.destroyAllWindows()

注意事项

  1. 阻塞与非阻塞:

    • 使用 0 作为延迟值将使程序无限期地等待用户输入。
    • 指定一个正数值（如 1000）将使程序等待最多 1 秒（1000 毫秒）。

  2. 和 cv2.imshow 配合使用:

    • cv2.imshow 用于展示图像，而 cv2.waitKey 控制图像窗口的行为。因此，它们通常是一起使用的。

  3. 多按键响应:

    • 可以使用 key 变量的返回值来执行不同的操作，例如在图形用户界面 (GUI) 应用中或在处理不同的图像时。
    • 可以通过 ord() 函数获取字符的 ASCII 值，以便比较按键。

9.cv2.namedWindow

cv2.namedWindow 是 OpenCV 中用于创建一个窗口的函数，您可以为其指定名称以及窗口的属性和行为。使用 cv2.namedWindow 可以更灵活地管理窗口的外观和行为，特别是在需要不同窗口模式（如调整窗口大小或全屏显示）时。

函数签名

cv2.namedWindow(winname, flags)

参数

使用示例

以下是创建一个窗口并显示图像的基本示例：

import cv2

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

# 检查图像是否成功加载
if image is None:
    print("Error: Could not open or find the image.")
else:
    # 创建一个可调整大小的窗口
    cv2.namedWindow('My Window', cv2.WINDOW_NORMAL)

    # 显示图像
    cv2.imshow('My Window', image)

    # 等待用户按键
    cv2.waitKey(0)
    
    # 关闭所有窗口
    cv2.destroyAllWindows()

注意事项

  1. 创建窗口前显示图像:

    • 如果先使用 cv2.imshow 方法显示图像而不先调用 cv2.namedWindow，OpenCV 会使用默认设置创建窗口。为了使用特定的窗口标志，最好在显示图像之前调用 cv2.namedWindow。

  2. 窗口状态:

    • 使用 cv2.WINDOW_NORMAL 可以拖动和调整窗口大小，而 cv2.WINDOW_AUTOSIZE 将使窗口大小固定为图像大小，用户无法调整。

  3. 多窗口支持:

    • 可以在同一程序中使用 cv2.namedWindow 创建多个窗口，每个窗口可以有不同的名称和特性。

  4. 窗口关闭:

    • 若要关闭创建的窗口，可使用 cv2.destroyWindow(winname) 关闭特定窗口，或者使用 cv2.destroyAllWindows() 关闭所有窗口。

10.cv2.imwrite()

cv2.imwrite() 是 OpenCV 中用于将图像保存到文件的函数。它可用于保存处理后的图像，或者将捕获的图像保存到磁盘。

函数签名

cv2.imwrite(filename, img, params=None)

参数

返回值

使用示例

以下是使用 cv2.imwrite() 保存图像的基本示例：

import cv2

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

# 检查图像是否加载成功
if image is None:
    print("Error: Could not open or find the image.")
else:
    # 处理图像（例如，将其转换为灰度图）
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # 保存处理后的图像
    if cv2.imwrite('gray_image.jpg', gray_image):
        print("Image successfully saved as gray_image.jpg")
    else:
        print("Error: Could not save the image.")

注意事项

  1. 文件路径:

    • 确保提供的文件路径正确并且程序有写入权限。如果路径不存在，则保存将失败。

  2. 文件格式:

    • 文件扩展名应与图像格式匹配。例如, 如果您指定 .jpg，确保图像是有效的 JPEG 格式。

  3. 参数使用:

    • 对于 JPEG 格式，可以设置图像质量，例如：params = [cv2.IMWRITE_JPEG_QUALITY, 90]。

  4. 返回值检查:

    • 总是检查返回值，以确保图像保存成功。

常见问题

总结

cv2.imwrite() 是一个简单而实用的函数，可以在图像处理和计算机视觉项目中将处理后的图像保存到磁盘。正确使用此函数，能够有效地存储和管理图像文件。

11. 二值位图 (1-bit Bitmap)

  1. 概述:

    • 二值位图是一种极简的图像表示方式，每个像素仅用1位来表示。0通常代表黑色，1代表白色（或反之），创造出黑白二色图像。

  2. 特点:

    • 存储效率: 由于每个像素只需1位，二值图像相较于其他颜色深度的图像（如8位、24位等）占用的存储空间更小，适合于存储纯黑白图像。
    • 适用场景: 常用于文本扫描、条形码识别、文档处理以及某些类型的图形设计，尤其是需要清晰边界和形状识别的应用。
    • 性能: 图像处理算法在处理二值图像时效率较高，因为操作的复杂度低于彩色图像。

  3. 表示:

    • 二值图像通过一个二维数组来表示，其中每个元素对应图像中的一个像素，例如： 
      0 1 1 0
1 0 0 1
1 1 0 0
0 0 1 1

  4. 应用:

    • 图像的阈值处理：将灰度图像转换为二值图像，用于提取特征。
    • 版面设计或图形设计中黑白图形的使用。

总结

二值位图是实现黑白图像表示的有效方法，具有较高的存储效率和处理速度，广泛应用于各种需要简单视觉表达的场合。
在计算机图像处理中，颜色空间及其表示法是非常重要的概念。以下是对位图表示法、GRAY色彩空间、RGB色彩空间和BGR色彩空间的简要说明：

12. GRAY色彩空间

13. RGB色彩空间

14. BGR色彩空间

总结

不同的颜色空间和位图表示法适用于不同的应用和需求。在图像处理过程中，选择合适的色彩空间和表示方法可以提高处理效率和结果的准确性。

15.获取图像的属性

在 OpenCV 中，获取图像的属性通常涉及到读取图像后的一些基本信息。以下是如何使用 OpenCV 获取图像属性的几个关键步骤：

1. 导入 OpenCV 库

首先，确保你已经安装了 OpenCV，并在你的 Python 脚本中导入它：

import cv2

2. 读取图像

使用 cv2.imread() 方法读取图像：

image = cv2.imread('path_to_image.jpg')

3. 获取图像属性

你可以通过属性和方法来获取图像的各种参数：

height, width, channels = image.shape
print(f'Height: {height}, Width: {width}, Channels: {channels}')

size = image.size
print(f'Size in bytes: {size}')

data_type = image.dtype
print(f'Data type: {data_type}')

4. 示例代码

以下是一个完整的示例代码，演示如何读取一幅图像并获取其属性：

import cv2

# 读取图像
image = cv2.imread('path_to_image.jpg')

if image is not None:
    # 获取图像的属性
    height, width, channels = image.shape
    size = image.size
    data_type = image.dtype

    print(f'Height: {height}')
    print(f'Width: {width}')
    print(f'Channels: {channels}')
    print(f'Size in bytes: {size}')
    print(f'Data type: {data_type}')
else:
    print("Error: Image not found or unable to read.")

注意事项

利用上述方法，你可以轻松获取图像的各种基础属性，为进一步的图像处理和分析打下基础。

16.BGR值的指定和修改

在 OpenCV 中，你可以读取和修改图像的像素值。以下是如何读取特定灰度图像和彩色图像像素坐标的 BGR 值，并如何修改特定图像像素坐标的 BGR 值的示例。

1. 引入 OpenCV 库

首先，确保你已经安装了 OpenCV，并在你的 Python 脚本中导入它：

import cv2

2. 读取灰度图像和彩色图像

使用 cv2.imread() 方法读取图像。

gray_image = cv2.imread('path_to_gray_image.jpg', cv2.IMREAD_GRAYSCALE)

color_image = cv2.imread('path_to_color_image.jpg', cv2.IMREAD_COLOR)

3. 读取特定像素坐标的值

假设要获取像素坐标 (x, y) 的 BGR 值：

x, y = 50, 100  # 设置特定像素坐标
bgr_value = color_image[y, x]  # 注意 OpenCV 使用 (y, x) 作为索引
print(f'BGR value at ({x}, {y}): {bgr_value}')  # 输出 BGR 值

x, y = 50, 100  # 设置特定像素坐标
gray_value = gray_image[y, x]  # 注意 OpenCV 使用 (y, x) 作为索引
print(f'Gray value at ({x}, {y}): {gray_value}')  # 输出灰度值

4. 修改特定像素坐标的 BGR 值

假设要将 color_image 上坐标 (x, y) 的 BGR 值修改为 (255, 0, 0)（红色）：

x, y = 50, 100  # 设置特定像素坐标
color_image[y, x] = [255, 0, 0]  # 修改 BGR 值为红色

5. 保存修改过的图像

如果你想保存修改后的图像，可以使用 cv2.imwrite() 方法：

cv2.imwrite('modified_image.jpg', color_image)

综合示例代码

这是一个完整的代码示例，展示了以上所有步骤：

import cv2

# 读取灰度图像
gray_image = cv2.imread('path_to_gray_image.jpg', cv2.IMREAD_GRAYSCALE)

# 读取彩色图像
color_image = cv2.imread('path_to_color_image.jpg', cv2.IMREAD_COLOR)

# 设置特定像素坐标
x, y = 50, 100  

# 读取彩色图像的 BGR 值
bgr_value = color_image[y, x]
print(f'BGR value at ({x}, {y}): {bgr_value}')  

# 读取灰度图像的像素值
gray_value = gray_image[y, x]
print(f'Gray value at ({x}, {y}): {gray_value}')  

# 修改彩色图像特定像素的 BGR 值
color_image[y, x] = [255, 0, 0]  # 将像素值修改为红色

# 保存修改后的图像
cv2.imwrite('modified_image.jpg', color_image)

注意事项

17.Numpy的数据类型

NumPy 是一个强大的科学计算库，其中的核心数据结构是 ndarray（N 维数组）。NumPy 提供了多种数据类型（dtype）来支持不同类型数据的存储和操作。下面，我将详细介绍 NumPy 中的主要数据类型及其用法。

1. 基本数据类型

dtype 描述 示例
int 整数类型，通常以 32 位或 64 位表示 np.array([1, 2, 3], dtype=np.int32)
float 浮点数类型，通常以 32 位（float32）或 64 位（float64）表示 np.array([1.0, 2.5], dtype=np.float64)
bool 布尔类型，仅支持 True 和 False np.array([True, False], dtype=np.bool_)
str 字符串类型，字符串长度可由用户指定 np.array(['hello', 'world'], dtype='U10')
object 任意 Python 对象 np.array([{'a': 1}, [1, 2, 3]], dtype=object)

2. 整数类型的详细介绍

NumPy 支持多种整数数据类型，常见的有：

3. 浮点数类型的详细介绍

NumPy 提供以下几种浮点数类型：

使用这些数据类型时，精度和存储空间是需要考虑的因素。

4. 字符串类型的详细介绍

5. 结构化数组（Structured Arrays）

结构化数组使你可以在一个数组中存储多种不同数据类型。你可以通过定义 dtype 来创建结构化数组。

# 定义一个结构
dtype = np.dtype([('name', 'U10'), ('age', 'i4')])
structured_arr = np.array([('Alice', 25), ('Bob', 30)], dtype=dtype)

6. 其他数据类型

dates = np.array(['2023-01-01', '2023-01-02'], dtype='datetime64')
time_diff = np.array([1, 2], dtype='timedelta64[D]')  # 表示天数

7. 检查数据类型

你可以使用 .dtype 属性检查 NumPy 数组的数据类型：

arr = np.array([1, 2, 3])
print(arr.dtype)  # 输出: int64（或int32，取决于平台）

8. 类型转换

NumPy 允许你轻松地转换数组的数据类型：

arr_int = np.array([1, 2, 3], dtype=np.int32)
arr_float = arr_int.astype(np.float64)  # 转换为浮点数

总结

NumPy 提供了多种数据类型，以便用户选择适合其应用程序的最优格式。选择适当的数据类型有助于提高计算性能并降低内存消耗，使科学计算更加高效。

18.ndarray的属性

ndarray 是 NumPy 的核心数据结构，提供了多种属性以帮助用户了解和操作数组。以下是一些常用的 ndarray 属性及其描述：

1. ndarray.ndim

2. ndarray.shape

3. ndarray.size

4. ndarray.dtype

5. ndarray.itemsize

6. ndarray.nbytes

7. ndarray.T

8. ndarray.flat

9. ndarray.real 和 ndarray.imag

10. ndarray.data

11. ndarray.strides

12. ndarray.base

总结

ndarray 属性提供了关于数组维度、形状、大小、数据类型等信息的关键访问。理解这些属性对于有效地使用 NumPy 进行科学计算和数据分析至关重要。

19.使用array()函数建立一维数组

使用 numpy.array() 函数可以很方便地创建一维数组。以下是一些关于如何使用 numpy.array() 创建一维数组的例子和相关解释。

1. 基本用法

你可以直接传入一个列表（或元组），这样可以创建一个一维数组。

import numpy as np

# 创建一维数组
arr = np.array([1, 2, 3, 4, 5])
print(arr)

输出：

[1 2 3 4 5]

2. 使用不同的数据类型

你可以通过 dtype 参数指定数组的数据类型。

# 创建一维整数数组
arr_int = np.array([1, 2, 3, 4, 5], dtype=int)
print(arr_int)
print(arr_int.dtype)  # 输出: int64 (或 int32，取决于平台)

# 创建一维浮点数组
arr_float = np.array([1, 2, 3, 4, 5], dtype=float)
print(arr_float)
print(arr_float.dtype)  # 输出: float64

3. 创建包含字符串的数组

你可以创建包含字符串的数组：

arr_str = np.array(['a', 'b', 'c'])
print(arr_str)
print(arr_str.dtype)  # 输出: <U1 (Unicode字符)

4. 从其他数据类型创建一维数组

你可以从其他类似数组的对象（如列表、元组等）创建一维数组：

# 使用元组创建一维数组
arr_tuple = np.array((10, 20, 30))
print(arr_tuple)  # 输出: [10 20 30]

5. 创建随机的一维数组

你可以使用 NumPy 的随机模块来创建随机的一维数组：

# 创建包含5个随机数的一维数组
arr_random = np.random.rand(5)
print(arr_random)

6. 使用全零或全一创建一维数组

你可以使用 np.zeros() 或 np.ones() 创建全零或全一的一维数组：

# 创建一个包含5个零的一维数组
arr_zeros = np.zeros(5)
print(arr_zeros)  # 输出: [0. 0. 0. 0. 0.]

# 创建一个包含5个一的一维数组
arr_ones = np.ones(5)
print(arr_ones)  # 输出: [1. 1. 1. 1. 1.]

总结

使用 numpy.array() 可以非常方便地创建一维数组，你可以根据需要选择相应的数据类型和数据来源。NumPy 提供的许多辅助函数（如 np.zeros()、np.ones() 和 np.random.rand()）使得创建特定结构的数组变得更加简单和灵活。

20.使用array()建立多维数组

使用 numpy.array() 函数可以方便地创建多维数组。下面我们将通过几个示例展示如何创建二维和三维数组。

1. 创建二维数组

二维数组本质上是一个矩阵，可以用嵌套列表（或元组）来定义。

import numpy as np

# 创建一个二维数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr_2d)

输出：

[[1 2 3]
 [4 5 6]]

2. 指定数据类型

还可以指定数组的数据类型：

# 创建一个指定数据类型的二维数组
arr_2d_float = np.array([[1, 2, 3], [4, 5, 6]], dtype=float)
print(arr_2d_float)
print(arr_2d_float.dtype)  # 输出: float64

3. 创建三维数组

三维数组可以用三层嵌套列表来表示。

# 创建一个三维数组
arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr_3d)

输出：

[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

4. 使用其他函数创建多维数组

除了使用 numpy.array()，NumPy 还提供了一些函数来创建特定结构的多维数组，例如全零、全一或随机数组。

创建全零的二维数组

arr_zeros_2d = np.zeros((2, 3))  # 2行3列的全零数组
print(arr_zeros_2d)

输出：

[[0. 0. 0.]
 [0. 0. 0.]]

创建全一的三维数组

arr_ones_3d = np.ones((2, 2, 2))  # 2x2x2的全一数组
print(arr_ones_3d)

输出：

[[[1. 1.]
  [1. 1.]]

 [[1. 1.]
  [1. 1.]]]

创建随机的二维数组

arr_random_2d = np.random.rand(3, 4)  # 3行4列的随机数组
print(arr_random_2d)

5. 使用构造函数创建高维数组

通过嵌套列表或元组，你可以轻松创建任意维度的数组。例如，创建一个四维数组：

# 创建一个四维数组（2x2x2x2)
arr_4d = np.array([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
                   [[[9, 10], [11, 12]], [[13, 14], [15, 16]]]])
print(arr_4d)

输出：

[[[[ 1  2]
  [ 3  4]]

 [[ 5  6]
  [ 7  8]]]


 [[[ 9 10]
  [11 12]]

 [[13 14]
  [15 16]]]]

总结

使用 numpy.array() 函数，我们可以非常方便地创建多维数组，同时可以利用 NumPy 提供的其他函数来生成特定结构的数组。这些方式使得在数据处理和科学计算中能够灵活地创建和操作多维数据。

21.random.randint()

numpy.random.randint() 是 NumPy 中用于生成随机整数的函数，通常用于创建数组，包括多维数组。下面是一些使用 numpy.random.randint() 创建多维数组的基本用法示例。

1. 基本用法

numpy.random.randint(low, high=None, size=None) 函数的参数如下：

2. 创建一维数组

import numpy as np

# 创建一个包含5个随机整数的一维数组，范围在[0, 10)
arr_1d = np.random.randint(0, 10, size=5)
print(arr_1d)

3. 创建二维数组

# 创建一个2x3的二维数组，随机整数范围在[0, 10)
arr_2d = np.random.randint(0, 10, size=(2, 3))
print(arr_2d)

输出示例：

[[1 5 3]
 [8 0 4]]

4. 创建三维数组

# 创建一个2x2x3的三维数组，随机整数范围在[0, 10)
arr_3d = np.random.randint(0, 10, size=(2, 2, 3))
print(arr_3d)

输出示例：

[[[6 4 0]
  [8 0 9]]

 [[2 5 8]
  [3 1 6]]]

6. 总结

numpy.random.randint() 是一个非常实用的函数，用于生成指定范围内的随机整数。通过设置 size 参数，你可以轻松生成一维、二维、三维或更高维的随机整数数组。这对于模拟数据、测试算法或生成随机样本非常有用。

22.arange()函数

numpy.arange() 函数用于创建一个包含指定范围的均匀间隔的数组。它的基本语法如下：

numpy.arange([start,] stop[, step])

1. 创建一维数组

创建一个简单的从 0 到 9 的一维数组：

import numpy as np

# 创建一个从0到9的一维数组
arr_1d = np.arange(10)
print(arr_1d)

输出：

[0 1 2 3 4 5 6 7 8 9]

2. 指定起始值和终止值

创建一个从 5 到 14 的一维数组：

# 创建一个从5到14的数组
arr_1d_range = np.arange(5, 15)
print(arr_1d_range)

输出：

[ 5  6  7  8  9 10 11 12 13 14]

3. 指定步长

创建一个从 0 到 20 的数组，步长为 2：

# 创建一个从0到20，步长为2的数组
arr_1d_step = np.arange(0, 20, 2)
print(arr_1d_step)

输出：

[ 0  2  4  6  8 10 12 14 16 18]

4. 创建二维数组

虽然 arange() 本身只会生成一维数组，但可以将其结果 reshape 成多维数组。以下是将一维数组转换为二维数组的示例：

# 创建一个从0到11的数组，并reshape为2行6列的二维数组
arr_2d = np.arange(12).reshape(2, 6)#如果其中一个元素是-1，这表示将依照另一个元素安排元素内容。
print(arr_2d)

输出：

[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]]

5. 创建三维数组

同样，可以创建一维数组并 reshape 成三维数组：

# 创建一个从0到23的数组，并reshape为2x3x4的三维数组
arr_3d = np.arange(24).reshape(2, 3, 4)
print(arr_3d)

输出：

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

6. 使用浮点数

arange() 也可以用于创建浮点型的数组，例如：

# 创建一个从0到1的数组，步长为0.1
arr_float = np.arange(0, 1, 0.1)
print(arr_float)

输出：

[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

总结

numpy.arange() 是一个非常实用的函数，可以用于创建包含指定范围和步长的数组。它的灵活性使得在数据处理和科学计算中非常高效，尤其在需要生成连续数字的情况。

23.一维数组的四则运算

在 NumPy 中，一维数组的四则运算是非常简单且高效的。NumPy 的广播功能使得数组之间的运算非常灵活。下面是对一维数组进行四则运算的基本示例。

1. 导入 NumPy

首先，需要导入 NumPy 库：

import numpy as np

2. 创建一维数组

我们先创建两个一维数组：

# 创建两个一维数组
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

3. 加法

一维数组的加法：

# 数组加法
add_result = a + b
print("Addition:", add_result)

输出：

Addition: [ 6  8 10 12]

4. 减法

一维数组的减法：

# 数组减法
sub_result = a - b
print("Subtraction:", sub_result)

输出：

Subtraction: [-4 -4 -4 -4]

5. 乘法

一维数组的乘法：

# 数组乘法
mul_result = a * b
print("Multiplication:", mul_result)

输出：

Multiplication: [ 5 12 21 32]

6. 除法

一维数组的除法：

# 数组除法
div_result = a / b
print("Division:", div_result)

输出：

Division: [0.2        0.33333333 0.42857143 0.5       ]

7. 其他运算

幂运算

您还可以进行幂运算：

# 数组的幂运算
pow_result = a ** 2
print("Power:", pow_result)

输出：

Power: [ 1  4  9 16]

8. 广播示例

NumPy 还支持广播功能，可以把标量与数组进行运算：

# 数组与标量的加法
scalar_add = a + 2
print("Scalar Addition:", scalar_add)

输出：

Scalar Addition: [3 4 5 6]

总结

NumPy 提供了对一维数组进行高效的四则运算的支持，通过简单的运算符即可实现复杂的数学运算。这在数据分析和科学计算中是非常有用的。

24.一维数组的关系运算符及运算

在 NumPy 中，可以使用关系运算符（如 <, >, <=, >=, ==, !=）对一维数组进行比较操作。这些运算符返回布尔数组，表示每个元素的比较结果。以下是如何使用这些运算符的示例：

1. 导入 NumPy

首先，需要导入 NumPy 库：

import numpy as np

2. 创建一维数组

我们先创建一个一维数组：

# 创建一个一维数组
a = np.array([1, 2, 3, 4])
b = np.array([3, 2, 1, 4])

3. 使用关系运算符

下面是使用关系运算符的具体示例：

3.1. 大于运算符 (>)

# a 中每个元素大于 b 中的对应元素
result_greater = a > b
print("a > b:", result_greater)

输出：

a > b: [False False  True False]

3.2. 小于运算符 (<)

# a 中每个元素小于 b 中的对应元素
result_less = a < b
print("a < b:", result_less)

输出：

a < b: [ True False False False]

3.3. 大于等于运算符 (>=)

# a 中每个元素大于或等于 b 中的对应元素
result_greater_equal = a >= b
print("a >= b:", result_greater_equal)

输出：

a >= b: [False  True  True  True]

3.4. 小于等于运算符 (<=)

# a 中每个元素小于或等于 b 中的对应元素
result_less_equal = a <= b
print("a <= b:", result_less_equal)

输出：

a <= b: [ True  True False  True]

3.5. 等于运算符 (==)

# a 中每个元素等于 b 中的对应元素
result_equal = a == b
print("a == b:", result_equal)

输出：

a == b: [False  True False  True]

3.6. 不等于运算符 (!=)

# a 中每个元素不等于 b 中的对应元素
result_not_equal = a != b
print("a != b:", result_not_equal)

输出：

a != b: [ True False  True False]

4. 逻辑运算

您还可以将多个布尔数组结合起来进行逻辑运算，例如使用 &（与）、|（或）和 ~（非）操作：

# 逻辑与
result_and = (a > 2) & (b < 4)
print("Logical And:", result_and)

# 逻辑或
result_or = (a < 2) | (b > 2)
print("Logical Or:", result_or)

# 逻辑非
result_not = ~(a == 2)
print("Logical Not:", result_not)

总结

NumPy 的关系运算符允许对数组进行逐元素比较，并返回布尔数组，便于进一步分析和处理。在数据分析和科学计算中，这些运算非常有用。

25.数组切片

数组切片是 NumPy 中一个非常强大的功能，允许你方便地提取和修改数组的部分内容。以下是对一维和二维数组切片的介绍和示例。

1. 导入 NumPy

首先，我们需要导入 NumPy：

import numpy as np

2. 创建一维数组

开始创建一个一维数组：

# 创建一维数组
arr_1d = np.array([10, 20, 30, 40, 50, 60])

3. 一维数组切片

使用冒号 : 表示范围：

# 提取从索引1到索引4的元素（不包括索引4）
slice_1d = arr_1d[1:4]
print("Slice 1D:", slice_1d)

输出：

Slice 1D: [20 30 40]

# 提取从开始到索引3的元素
slice_1d_start = arr_1d[:4]
print("Slice 1D Start:", slice_1d_start)

输出：

Slice 1D Start: [10 20 30 40]

# 提取从索引2到结束的元素
slice_1d_end = arr_1d[2:]
print("Slice 1D End:", slice_1d_end)

输出：

Slice 1D End: [30 40 50 60]

负索引可用于从数组末尾反向索引：

# 提取最后两个元素
slice_1d_negative = arr_1d[-2:]
print("Slice 1D Negative:", slice_1d_negative)

输出：

Slice 1D Negative: [50 60]

4. 二维数组切片

二维数组切片的语法稍有不同，我们需要指定行和列的范围。

# 创建二维数组
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# 提取第1行
row_slice = arr_2d[1, :]
print("Row Slice:", row_slice)

输出：

Row Slice: [4 5 6]

# 提取第2列
col_slice = arr_2d[:, 1]
print("Column Slice:", col_slice)

输出：

Column Slice: [2 5 8]

# 提取前两行和前两列
sub_matrix = arr_2d[:2, :2]
print("Sub Matrix:", sub_matrix)

输出：

Sub Matrix: [[1 2]
             [4 5]]

5. 修改切片的值

切片也可以用于修改数组中的元素：

# 修改一维数组的切片
arr_1d[1:4] = [100, 200, 300]
print("Modified Array 1D:", arr_1d)

输出：

Modified Array 1D: [ 10 100 200 300  50  60]

6. 注意事项

  1. 切片复制：切片返回的不是原数组的副本，而是视图。修改切片会影响原数组。
  2. 使用 copy()：如果想要获得数组的副本而非视图，可以使用 copy() 方法。
# 创建一个切片的副本
slice_copy = arr_1d[1:4].copy()

总结

NumPy 的数组切片功能提供了一种方便的方式来提取和修改数组的部分内容。理解和掌握切片是高效处理数据的关键。

26.数组水平与垂直合并

在 NumPy 中，vstack() 和 hstack() 函数用于按垂直方向和水平方向将多个数组堆叠在一起。它们的用法比较简单，但非常有用，尤其是在处理多维数组时。

以下是这两个函数的详细说明和示例。

1. 导入 NumPy

首先，确保导入 NumPy 库：

import numpy as np

2. 使用 vstack()

vstack() 是按垂直方向（行方向）堆叠数组的函数。它接受一个由数组组成的元组或列表，并将这些数组在垂直方向上堆叠。

示例：

# 创建两个二维数组
arr1 = np.array([[1, 2, 3],
                 [4, 5, 6]])

arr2 = np.array([[7, 8, 9],
                 [10, 11, 12]])

# 使用 vstack 进行垂直堆叠
result_vstack = np.vstack((arr1, arr2))
print("Vertical Stack:\n", result_vstack)

输出：

Vertical Stack:
 [[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]

3. 使用 hstack()

hstack() 是按水平方向（列方向）堆叠数组的函数。同样，它也接受一个由数组组成的元组或列表，并将在水平方向上堆叠这些数组。

示例：

# 使用 hstack 进行水平堆叠
result_hstack = np.hstack((arr1, arr2))
print("Horizontal Stack:\n", result_hstack)

输出：

Horizontal Stack:
 [[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

4. 注意事项

  1. 维度匹配：在使用这两个函数时，需要确保传入的数组在可以堆叠的维度上具有相同的形状。例如，使用 vstack() 时，数组的列数必须相同；使用 hstack() 时，数组的行数必须相同。

  2. 数组类型：传入的数组可以是不同的数据类型，NumPy 会自动进行类型转换，以适应高精度的合并。

5. 实际应用

6. 总结

vstack() 和 hstack() 是非常方便的工具，可以让你轻松地将数组按照需要进行合并。在数据科学和计算中，它们的应用非常广泛。

27.BGR色彩空间与RGB色彩空间和GRAY色彩空间的转换

在图像处理中，BGR、RGB和灰度（GRAY）色彩空间是常见的色彩格式。以下是如何在 Python 中（特别是使用 OpenCV 库）进行这几种色彩空间之间的转换。

1. BGR 转 RGB

OpenCV 默认使用 BGR 格式，而许多其他库（例如 Matplotlib）使用 RGB 格式。可以通过简单的数组切片进行转换：

import cv2

# 读取 BGR 格式的图像
bgr_image = cv2.imread('image.jpg')

# 转换为 RGB
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)

2. RGB 转 BGR

同样地，将 RGB 转换为 BGR 也很简单：

# 转换为 BGR
bgr_image = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR)

3. BGR 转 GRAY

要将 BGR 图像转换为灰度图像，可以使用以下方法：

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

4. RGB 转 GRAY

可以使用相同的转换函数将 RGB 图像转换为灰度图像：

# 转换为灰度图像
gray_image_from_rgb = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2GRAY)

5. GRAY 转 BGR 和 RGB

如果需要将灰度图像转换回 BGR 或 RGB 格式，可以使用 cv2.cvtColor 进行处理：

# 将灰度图像转换为 BGR
bgr_from_gray = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2BGR)

# 将灰度图像转换为 RGB
rgb_from_gray = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)

示例代码

以下是一个完整的示例代码，用于展示如何在不同色彩空间之间转换：

import cv2

# 读取 BGR 图像
bgr_image = cv2.imread('image.jpg')

# BGR 转 RGB
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)

# BGR 转 GRAY
gray_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2GRAY)

# GRAY 转 BGR
bgr_from_gray = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2BGR)

# GRAY 转 RGB
rgb_from_gray = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)

# 可以使用 cv2.imshow 来显示图像
cv2.imshow('BGR Image', bgr_image)
cv2.imshow('RGB Image', rgb_image)
cv2.imshow('Gray Image', gray_image)
cv2.imshow('BGR from Gray', bgr_from_gray)
cv2.imshow('RGB from Gray', rgb_from_gray)

cv2.waitKey(0)
cv2.destroyAllWindows()

总结

使用 OpenCV，非常容易在 BGR、RGB 和灰度图像之间进行转换。只需使用适当的 cv2.cvtColor 函数。

28.HSV色彩空间

HSV（色相、饱和度、明亮度）色彩空间是一种常用于图像处理的颜色表示方法，它相较于 RGB 和 BGR 色彩空间更符合人类的视觉感知。HSV 色彩空间中的三个通道分别代表以下内容：

HSV 与 BGR/RGB 的转换

在使用 Python 时，可以利用 OpenCV 库来进行 HSV 和 BGR/RGB 之间的转换。

1. BGR 转 HSV

import cv2

# 读取 BGR 图像
bgr_image = cv2.imread('image.jpg')

# BGR 转 HSV
hsv_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2HSV)

2. HSV 转 BGR

# HSV 转 BGR
bgr_image_from_hsv = cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)

3. RGB 转 HSV

# RGB 转 HSV
rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB)
hsv_image_from_rgb = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2HSV)

4. HSV 转 RGB

# HSV 转 RGB
rgb_image_from_hsv = cv2.cvtColor(hsv_image, cv2.COLOR_HSV2RGB)

示例代码

下面是一个完整的示例，展示如何在 BGR 和 HSV 色彩空间之间进行转换：

import cv2

# 读取 BGR 图像
bgr_image = cv2.imread('image.jpg')

# BGR 转 HSV
hsv_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2HSV)

# HSV 转 BGR
bgr_from_hsv = cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)

# 显示图像
cv2.imshow('BGR Image', bgr_image)
cv2.imshow('HSV Image', hsv_image)
cv2.imshow('BGR from HSV', bgr_from_hsv)

cv2.waitKey(0)
cv2.destroyAllWindows()

HSV 色彩空间提供了一种直观的方式来理解和处理颜色，特别在图像处理、计算机视觉和人工智能等领域。借助 OpenCV，进行色彩空间之间的转换变得非常简单。

29.拆分与合并色彩通道

在图像处理中，拆分和合并色彩通道是常见的操作，用于对每个通道进行独立的处理或者提取特定的色彩信息。以下是如何使用 Python 的 OpenCV 库来拆分和合并色彩通道的示例。

拆分色彩通道

可以使用 cv2.split() 函数拆分图像的各个色彩通道。以下是一个将 BGR 图像拆分为蓝色、绿色和红色通道的示例：

import cv2

# 读取 BGR 图像
bgr_image = cv2.imread('image.jpg')

# 拆分色彩通道
b_channel, g_channel, r_channel = cv2.split(bgr_image)

# 显示拆分后的通道
cv2.imshow('Blue Channel', b_channel)
cv2.imshow('Green Channel', g_channel)
cv2.imshow('Red Channel', r_channel)

cv2.waitKey(0)
cv2.destroyAllWindows()

合并色彩通道

可以使用 cv2.merge() 函数将多个色彩通道合并回一个图像。以下是一个将拆分开的通道重新合并为 BGR 图像的示例：

# 合并色彩通道
merged_image = cv2.merge((b_channel, g_channel, r_channel))

# 显示合并后的图像
cv2.imshow('Merged Image', merged_image)

cv2.waitKey(0)
cv2.destroyAllWindows()

应用示例

可以在拆分的通道上进行各种操作，然后再合并。例如，下面的示例将红色通道设置为零，然后合并回去：

# 将红色通道设置为零
r_channel[:] = 0

# 重新合并通道
modified_image = cv2.merge((b_channel, g_channel, r_channel))

# 显示修改后的图像
cv2.imshow('Modified Image', modified_image)

cv2.waitKey(0)
cv2.destroyAllWindows()

总结

以上示例可以轻松地扩展到其他色彩空间（如 HSV 或 YUV），方法基本相同。

30.建立和编辑灰度图像和彩色图像

在 Python 中使用 OpenCV 库来建立和编辑灰度图像和彩色图像是相对简单的。下面是一些基本的示例，展示如何创建和编辑灰度图像和彩色图像。

1. 安装 OpenCV

首先，确保你已经安装了 OpenCV，可以使用以下命令进行安装：

pip install opencv-python

2. 创建和编辑灰度图像

创建灰度图像

import cv2
import numpy as np

# 创建一个 256x256 的黑色图像（灰度）
gray_image = np.zeros((256, 256), dtype=np.uint8)

# 在图像中增加一些白色的矩形
cv2.rectangle(gray_image, (50, 50), (200, 200), 255, -1)

# 显示图像
cv2.imshow("Gray Image", gray_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存图像
cv2.imwrite("gray_image.png", gray_image)

编辑灰度图像

# 读取图像
gray_image = cv2.imread("gray_image.png", cv2.IMREAD_GRAYSCALE)

# 应用高斯模糊
blurred_image = cv2.GaussianBlur(gray_image, (15, 15), 0)

# 显示结果
cv2.imshow("Blurred Gray Image", blurred_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存编辑后的图像
cv2.imwrite("blurred_gray_image.png", blurred_image)

3. 创建和编辑彩色图像

创建彩色图像

# 创建一个 256x256 的黑色图像（彩色）
color_image = np.zeros((256, 256, 3), dtype=np.uint8)

# 在图像中增加一些彩色的圆形
cv2.circle(color_image, (128, 128), 100, (0, 255, 0), -1)  # 绿色圆

# 显示图像
cv2.imshow("Color Image", color_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存图像
cv2.imwrite("color_image.png", color_image)

编辑彩色图像

# 读取图像
color_image = cv2.imread("color_image.png")

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

# 显示结果
cv2.imshow("Gray from Color", gray_from_color)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 保存灰度图像
cv2.imwrite("gray_from_color.png", gray_from_color)

总结

以上示例展示了如何使用 OpenCV 创建和编辑灰度图像和彩色图像。这只是基本的操作，你可以根据需求使用 OpenCV 提供的其他功能进行更复杂的图像处理。

32.item和itemset

在OpenCV中，ndarray是用于存储图像数据和其他多维数据的主要数据结构。下面是关于item和itemset方法的基本介绍：

item()

import cv2
# 假设img是一个已经加载的图像，是一个二维数组
pixel_value = img.item(3, 4)

itemset()

import cv2
# 假设img是一个已经加载的图像，是一个二维数组
img.itemset((3, 4), 255)

在使用这些方法时，需要注意的是，虽然item和itemset方法在OpenCV中可用，但通常推荐使用NumPy风格的索引和切片操作来访问和修改数组元素，因为它们更直观、更灵活，且通常性能更好。例如：

# 获取像素值
pixel_value = img[3, 4]
# 设置像素值
img[3, 4] = 255

在使用这些方法时，确保你的索引值在数组的边界内，以避免索引错误。

31.绘制

在OpenCV中，可以非常方便地绘制各种形状（如直线、矩形、圆形、椭圆、椭圆弧、多边形），还可以在图像上输出文本，包括中英文字符串，并实现一个简单的滚动条。下面是一个完整示例代码，演示了这些功能：

示例代码

import cv2
import numpy as np

# 创建一个空白图像
image = np.zeros((500, 800, 3), dtype=np.uint8)

# 绘制直线
cv2.line(image, (50, 50), (700, 50), (255, 0, 0), 5)  # 红色直线

# 绘制矩形
cv2.rectangle(image, (50, 70), (150, 150), (0, 255, 0), -1)  # 绿色填充矩形

# 绘制圆形
cv2.circle(image, (400, 100), 50, (0, 0, 255), -1)  # 蓝色填充圆

# 绘制椭圆
cv2.ellipse(image, (600, 100), (100, 50), 0, 0, 180, (255, 255, 0), -1)  # 黄色椭圆

# 绘制椭圆弧
cv2.ellipse(image, (600, 300), (100, 50), 0, 0, 270, (255, 255, 255), 2)  # 白色椭圆弧

# 绘制多边形
points = np.array([[300, 250], [350, 350], [250, 350]], np.int32)
cv2.polylines(image, [points], isClosed=True, color=(255, 0, 255), thickness=2)  # 紫色多边形

# 输出中文和英文文本
cv2.putText(image, 'Hello OpenCV', (50, 400), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# 创建一个滚动条的回调函数
def nothing(x):
    pass

# 创建一个窗口
cv2.namedWindow('Drawing Shapes')

# 创建滚动条
cv2.createTrackbar('Thickness', 'Drawing Shapes', 1, 10, nothing)

while True:
    # 复制图像
    temp_image = image.copy()
    
    # 获取滚动条值
    thickness = cv2.getTrackbarPos('Thickness', 'Drawing Shapes')
    
    # 绘制直线带有滚动条调整的线宽
    cv2.line(temp_image, (50, 50), (700, 50), (255, 0, 0), thickness)
    
    # 显示图像
    cv2.imshow('Drawing Shapes', temp_image)

    # 监听键盘事件，按Esc键退出
    if cv2.waitKey(1) & 0xFF == 27:
        break

cv2.destroyAllWindows()

代码解释

  1. 创建空白图像：生成一个黑色背景的图像。

  2. 绘制各种形状：

    • 直线：使用cv2.line()绘制红色直线。
    • 矩形：使用cv2.rectangle()绘制绿色矩形。
    • 圆形：使用cv2.circle()绘制蓝色圆形。
    • 椭圆：使用cv2.ellipse()绘制黄色椭圆。
    • 椭圆弧：使用cv2.ellipse()绘制白色椭圆弧。
    • 多边形：使用cv2.polylines()绘制紫色多边形。

  3. 输出文本：使用cv2.putText()在图像上输出英文和中文文本。

  4. 创建滚动条：使用cv2.createTrackbar()创建一个滚动条以调整绘制的线宽。

  5. 主循环：

    • 显示图像并获取滚动条的值，动态调整绘制的直线宽度。
    • 按Esc键退出循环。

注意事项

32.事件机制

OpenCV 的事件机制允许用户处理鼠标事件（如点击、移动等）和键盘事件，以实现交互式的图像处理应用。下面是 OpenCV 事件机制的基本概念与示例：

事件类型

  1. 鼠标事件

    • cv2.EVENT_LBUTTONDOWN：左键按下事件
    • cv2.EVENT_RBUTTONDOWN：右键按下事件
    • cv2.EVENT_MBUTTONDOWN：中键按下事件
    • cv2.EVENT_MOUSEMOVE：鼠标移动事件

  2. 键盘事件

    • 任何按键被按下都可以通过 cv2.waitKey() 来处理。

使用步骤

  1. 定义鼠标回调函数

    • 使用 cv2.setMouseCallback() 函数来注册鼠标事件处理函数。

  2. 创建窗口和显示图像

    • 通过 cv2.imshow() 创建窗口并显示图像。

  3. 处理事件

    • 通过 cv2.waitKey() 保持窗口不关闭，并转换键盘事件。

示例代码

以下示例展示了如何处理鼠标点击事件并在图像上绘制点：

import cv2
import numpy as np

# 创建一个空图像
image = np.zeros((500, 800, 3), dtype=np.uint8)

# 鼠标回调函数
def mouse_callback(event, x, y, flags, param):
    if event == cv2.EVENT_LBUTTONDOWN:
        cv2.circle(image, (x, y), 10, (0, 255, 0), -1)  # 绘制绿色圆圈
        cv2.imshow('Image', image)

# 创建窗口
cv2.namedWindow('Image')
cv2.setMouseCallback('Image', mouse_callback)

while True:
    cv2.imshow('Image', image)
    key = cv2.waitKey(1) & 0xFF
    if key == 27:  # 按 'Esc' 键退出
        break

cv2.destroyAllWindows()

代码解释

  1. 创建空图像：生成一个黑色背景的图像。

  2. 鼠标回调函数：mouse_callback 函数接收鼠标事件。

    • 当检测到左键按下事件时，在鼠标点击的位置绘制绿色圆圈。

  3. 窗口和事件循环：

    • 使用 cv2.namedWindow() 创建窗口，cv2.setMouseCallback() 注册鼠标回调函数。
    • 通过 cv2.imshow() 显示图像。循环持续到按下 Esc 键。

注意事项

总结

OpenCV 的事件机制使得用户能够在图像处理应用中添加交互性。通过鼠标和键盘事件的处理，用户可以实时地与图像进行互动，便于进行分析和调试。

33.加密/解密图片

在 OpenCV 中，可以利用 XOR 操作对图像实现一种简单的加密和解密方法。这种方法基于位运算的性质，利用相同的密钥进行两次 XOR 运算可以得到原始图像，实现了加密和解密的过程。下面是详细的原理解释和实现步骤。

XOR 操作的性质

XOR（异或）是一种简单的位运算，具有以下特性：

  1. 自反性：对于任意位 a，有 a XOR a = 0。
  2. 恒等性：对于任意位 a，有 a XOR 0 = a。
  3. 交换性：即 a XOR b = b XOR a。
  4. 结合性：即 (a XOR b) XOR c = a XOR (b XOR c)。

基于这些性质，如果我们将原始图像与一个密钥图像进行 XOR 计算，得到了加密后的图像。为了恢复原始图像，我们只需要再次将加密图像与同样的密钥图像进行 XOR 操作。

加密过程

  1. 选择密钥：生成一个与原始图像大小相同的密钥图像，密钥可以是随机生成的。
  2. 执行 XOR 操作：将原始图像与密钥图像进行按位 XOR 操作，得到加密图像。

加密公式：
Encrypted Image=Original Image⊕Key Image

解密过程

  1. 再次执行 XOR 操作：将加密图像与同样的密钥图像进行按位 XOR 操作，恢复出原始图像。

解密公式：
Decrypted Image=Encrypted Image⊕Key Image

示例代码

下面是一个基本的 OpenCV 示例，演示如何实现图像加密和解密。

import cv2
import numpy as np

# 加载原始图像
original_image = cv2.imread('input_image.jpg')

# 生成与原始图像相同大小的随机密钥
key_image = np.random.randint(0, 256, original_image.shape, dtype=np.uint8)

# 加密图像
encrypted_image = cv2.bitwise_xor(original_image, key_image)

# 保存加密后的图像
cv2.imwrite('encrypted_image.jpg', encrypted_image)

# 解密图像
decrypted_image = cv2.bitwise_xor(encrypted_image, key_image)

# 保存解密后的图像
cv2.imwrite('decrypted_image.jpg', decrypted_image)

# 展示图像
cv2.imshow('Original Image', original_image)
cv2.imshow('Encrypted Image', encrypted_image)
cv2.imshow('Decrypted Image', decrypted_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

注意事项

  1. 密钥的安全性：密钥的随机性和保密性直接影响加密的安全性，建议使用足够复杂的生成方式。
  2. 图像数据类型：确保图像和密钥均为 uint8 类型以避免溢出和数据误差。
  3. 加密级别：这种方法的安全性较低，容易被攻击，但可以在某些场景下作为简单的隐写技术使用。

通过以上原理和实现，可以使用 XOR 操作来进行简单的图像加密与解密。

34.add()

add() 函数用于执行两张图片的像素级加法运算。

函数原型:

cv2.add(src1, src2, dst=None, mask=None, dtype=None)

参数:

返回值:

工作原理:

add() 函数会将两张输入图像的对应像素值相加，并将结果保存到输出图像中。如果结果超过了数据类型的范围，则会进行截断，最高255。

import cv2
import numpy as np

# 加载两张图片
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# 检查图片是否加载成功
if img1 is None or img2 is None:
  print("无法加载图片")
  exit()

# 使用add()函数执行图像加法运算
added_image = cv2.add(img1, img2)

# 显示结果
cv2.imshow('加法运算结果', added_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

35.+

在 OpenCV 中，使用 + 符号进行数学加法运算时，它实际上是执行的是 NumPy 数组的元素级加法。

这意味着当你使用 + 符号对两张图片进行加法运算时，它会逐个像素地对它们进行加法运算，而不是像 cv2.add() 函数那样进行饱和处理。

示例：

import cv2
import numpy as np

# 加载两张图片
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# 使用 + 符号进行加法运算
added_image = img1 + img2

# 显示结果
cv2.imshow('加法运算结果', added_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

需要注意的是:

建议:

36.掩膜

在图像处理中，掩膜（Mask）是一个非常重要的概念，它可以用来选择图像中需要处理的区域，并对这些区域进行特定的操作，例如：

掩膜的实现:

掩膜通常是一个与图像尺寸相同的矩阵，矩阵中的元素值为0或1，分别代表不处理或处理。

创建掩膜的方法:

  1. 手动创建： 可以使用 NumPy 库创建掩膜，例如：
import numpy as np

mask = np.zeros((512, 512), dtype=np.uint8)
mask[100:400, 100:400] = 1
  1. 使用 OpenCV 函数: OpenCV 提供了一些函数可以创建掩膜，例如：

使用掩膜:

可以使用掩膜对图像进行各种操作，例如：

roi = img[mask == 1]

img[mask == 1] = [255, 0, 0]  # 将掩膜区域设置为蓝色

fused_img = img1 * mask + img2 * (1 - mask)

示例：

import cv2
import numpy as np

# 加载图像
img = cv2.imread('image.jpg')

# 创建掩膜
mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.uint8)
mask[100:400, 100:400] = 1

# 使用掩膜提取感兴趣区域
roi = img[mask == 1]

# 显示结果
cv2.imshow('ROI', roi)
cv2.waitKey(0)
cv2.destroyAllWindows()

总结：

掩膜是一种非常强大的图像处理工具，可以用来选择图像中需要处理的区域，并对这些区域进行特定的操作。通过使用掩膜，可以实现多种图像处理功能，例如提取感兴趣区域、修改图像特定区域、图像融合等。

37.cv2.addWeighted()

cv2.addWeighted() 函数是 OpenCV 中用于图像混合的函数，它可以将两张图像按照指定权重进行混合，从而实现图像的透明叠加、图像融合等效果。

函数原型:

cv2.addWeighted(src1, alpha, src2, beta, gamma)

参数说明:

原理:

cv2.addWeighted() 函数执行以下操作：

  1. 将两张图像分别乘以各自的权重 alpha 和 beta。
  2. 将两张图像的乘积结果相加。
  3. 将加法结果加上偏移量 gamma。

公式:

dst = alpha * src1 + beta * src2 + gamma

应用场景:

示例：

import cv2
import numpy as np

# 加载两张图像
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# 将 img1 和 img2 混合，权重分别为 0.5 和 0.5
blended_image = cv2.addWeighted(img1, 0.5, img2, 0.5, 0)

# 显示结果
cv2.imshow('混合后的图像', blended_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

注意事项:

总结:

cv2.addWeighted() 函数是一个非常实用的图像混合函数，可以用来实现多种图像处理效果，例如透明叠加、图像融合、图像混合等。

38.cv2.addWeighted()

cv2.addWeighted() 函数是 OpenCV 中用于图像混合的函数，它可以将两张图像按照指定权重进行混合，从而实现图像的透明叠加、图像融合等效果。

函数原型:

cv2.addWeighted(src1, alpha, src2, beta, gamma)

参数说明:

原理:

cv2.addWeighted() 函数执行以下操作：

  1. 将两张图像分别乘以各自的权重 alpha 和 beta。
  2. 将两张图像的乘积结果相加。
  3. 将加法结果加上偏移量 gamma。

公式:

dst = alpha * src1 + beta * src2 + gamma

应用场景:

示例：

import cv2
import numpy as np

# 加载两张图像
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# 将 img1 和 img2 混合，权重分别为 0.5 和 0.5
blended_image = cv2.addWeighted(img1, 0.5, img2, 0.5, 0)

# 显示结果
cv2.imshow('混合后的图像', blended_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

注意事项:

总结:

cv2.addWeighted() 函数是一个非常实用的图像混合函数，可以用来实现多种图像处理效果，例如透明叠加、图像融合、图像混合等。

39.bitwise_or

1. 按位或 (Bitwise OR) 的概念

按位或 (Bitwise OR) 是一种逻辑运算，它对两个数字（或在图像处理中是像素）的对应位进行比较。如果两个位中至少有一个为 1，则结果位为 1；否则结果位为 0。

2. 例子

3. 在图像处理中的应用

在图像处理中，bitwise_or 操作通常用于将两个图像合并，或将一个图像叠加到另一个图像上。

4. OpenCV 中的应用

在 OpenCV 中，bitwise_or 操作可以使用 cv2.bitwise_or() 函数实现。

5. 示例代码 (Python + OpenCV)

import cv2
import numpy as np

# 加载两张图片
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# 执行按位或操作
result = cv2.bitwise_or(img1, img2)

# 显示结果
cv2.imshow('图像 1', img1)
cv2.imshow('图像 2', img2)
cv2.imshow('按位或结果', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

解释

结果

bitwise_or 操作会将两张图片中的所有非零像素合并到结果图像中。这意味着，如果一张图片中的某个像素为 1，而另一张图片中的对应像素也为 1，则结果图像中该像素也将为 1。如果其中一张图片的对应像素为 0，而另一张图片为 1，则结果图像中该像素也将为 1。

其他应用

总结

按位或 (Bitwise OR) 操作是一种灵活的工具，可以用于各种图像处理任务，它可以将两个图像的对应像素进行合并或叠加。

40.bitwise_not

1. 按位取反 (Bitwise NOT) 的概念

按位取反 (Bitwise NOT) 是一种逻辑运算，它对一个数字的每一位进行取反操作。如果原位是 1，则取反后变为 0；如果原位是 0，则取反后变为 1。

2. 例子

3. 在图像处理中的应用

在图像处理中，bitwise_not 操作通常用于创建图像的反转版本，即黑色区域变为白色，白色区域变为黑色。

4. OpenCV 中的应用

在 OpenCV 中，bitwise_not 操作可以使用 cv2.bitwise_not() 函数实现。

5. 示例代码 (Python + OpenCV)

import cv2

# 加载一张图片
img = cv2.imread('image.jpg')

# 执行按位取反操作
result = cv2.bitwise_not(img)

# 显示结果
cv2.imshow('原图像', img)
cv2.imshow('按位取反结果', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

解释

结果

bitwise_not 操作会将原始图片中的每个像素的颜色反转。比如，如果原始图片中的一个像素是黑色 (0, 0, 0)，那么取反后的像素将是白色 (255, 255, 255)，反之亦然。

其他应用

总结

按位取反 (Bitwise NOT) 操作是一种简单的图像处理操作，它可以快速反转图像的每个像素，使其变得更易于分析或处理。

41.bitwise_xor

1. 按位异或 (Bitwise XOR) 的概念

按位异或 (Bitwise XOR) 是一种逻辑运算，它对两个数字（或在图像处理中是像素）的对应位进行比较。如果两个位不同，则结果位为 1；如果两个位相同，则结果位为 0。

2. 例子

3. 在图像处理中的应用

在图像处理中，bitwise_xor 操作通常用于：

4. OpenCV 中的应用

在 OpenCV 中，bitwise_xor 操作可以使用 cv2.bitwise_xor() 函数实现。

5. 示例代码 (Python + OpenCV)

import cv2

# 加载两张图片
img1 = cv2.imread('image1.jpg')
img2 = cv2.imread('image2.jpg')

# 执行按位异或操作
result = cv2.bitwise_xor(img1, img2)

# 显示结果
cv2.imshow('图像 1', img1)
cv2.imshow('图像 2', img2)
cv2.imshow('按位异或结果', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

解释

结果

bitwise_xor 操作会将两张图像中不同的像素保留，而相同的像素则会变为黑色。例如，如果 img1 中的一个像素是白色 (255, 255, 255)，而 img2 中的对应像素是黑色 (0, 0, 0)，则结果图像中该像素将是白色。如果 img1 和 img2 中的对应像素都是白色，则结果图像中该像素将是黑色。

其他应用

总结

按位异或 (Bitwise XOR) 操作是一种灵活的工具，可以用于各种图像处理任务，它可以比较两张图像的对应像素，并找出它们的差异或进行混合。

上一篇 下一篇

猜你喜欢

热点阅读