opencv-python的简单练习

题目1：读取一张彩色图像并将其转换为灰度图。

import cv2

# 读取名为 '1.png'的图片文件
img = cv2.imread('1.png')

# 将原图像从 BGR（Blue Green Red）颜色空间转换到灰度空间，存放在 img_gray 中
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 使用 imshow函数 显示灰度图片
cv2.imshow('img_gray', img_gray)
cv2.waitKey(0)

题目2：二值化与形态学操作‌

编写程序，读取一张彩色图像【flower.png】，将其转换为灰度图，然后进行二值化处理。

接着，对二值化后的图像执行腐蚀和膨胀操作，并显示处理前后的图像。

import cv2

# 读取名为 '12.png' 的图片文件
img = cv2.imread('12.png')

# 将原图片从 BGR 颜色空间转换为灰度空间
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 对灰度图像进行二值化处理，设定阈值为 127，大于该值的像素设定为 255（白色），小于等于该值的设定为 0（黑色）
thresh_1, img = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

# 创建一个 9x9 的矩形结构元素
ret = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 9))

# 使用矩形结构元素来对二值图像进行腐蚀操作
img_erode = cv2.erode(img, ret)

# 创建一个 3x3 的椭圆形结构元素
k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))

# 对腐蚀后的图像进行膨胀操作
img_erode_dilate = cv2.dilate(img_erode, k)

# 显示二值化后的图像和腐蚀后的图像
cv2.imshow('image_binary', img)
cv2.imshow('image_erode', img_erode)
cv2.waitKey(0)

‌题目3：图像变换与颜色识别‌

编写程序，读取一张彩色图像，执行以下操作：

1. 将图像缩放至指定大小（例如，宽度和高度都缩小为原来的一半）。
2. 对缩放后的图像应用仿射变换，实现图像的旋转（例如，旋转45度）。
3. 将图像从BGR颜色空间转换为HSV颜色空间，并提取出特定的颜色范围（例如，提取黄色区域）。
4. 显示处理后的图像，并在图像上标记出识别到的颜色区域。

import cv2
import numpy as np

# 读取名为 '12.png' 的图片
img = cv2.imread('12.png')

# 将图像的宽度缩小为原来的0.7倍，高度缩小为原来的0.5倍
img1 = cv2.resize(img, (0, 0), fx=0.7, fy=0.5)

# 获取一个将图像逆时针旋转45度，并且缩小0.5倍的旋转矩阵
m = cv2.getRotationMatrix2D((img.shape[1] / 2, img.shape[0] / 2), 45, 0.5)

# 对图像进行仿射变换（此处为旋转变换）并进行边界填充
img1 = cv2.warpAffine(img, m, (img1.shape[1], img1.shape[0]), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)

# 将BGR图像转换为HSV图像
img_hsv = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)

# 为HSV空间的黄色设定阈值
hsv_min = np.array([35, 43, 46])
hsv_max = np.array([77, 255, 255])

# 对HSV空间进行阈值过滤，得到黄色的掩码
img_mask_y = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 遍历所有像素，如果该像素在黄色掩码下的值为255，即为黄色区域，将该像素的颜色更改为R=255, G=35, B=79的颜色
for i in range(img_mask_y.shape[0]):
    for j in range(img_mask_y.shape[1]):
        if img_mask_y[i, j] == 255:
            img1[i, j, :] = (255, 35, 79)

# 展示处理后的图片
cv2.imshow('img1', img1)
cv2.waitKey(0)

‌题目4：图像矫正

编写程序，读取一张彩色图像，执行以下操作

1. 找到原图 和目标图的四个点，获取透视变换矩阵
2. 对图像应用透视变换，实现油画区域的矫正

import cv2
import numpy as np

# 读取名为 '13.png' 的图片文件
img = cv2.imread('13.png')

# 定义透视变换前后的四个边界点
p1 = np.array([[173, 141], [623, 34], [85, 497], [656, 555]], dtype=np.float32)

# 定义透视变换后左上、右上、左下和右下四个角的位置
p2 = np.array([[0, 0], [img.shape[1], 0], [0, img.shape[0]], [img.shape[1], img.shape[0]]], dtype=np.float32)

# 通过 getPerspectiveTransform 函数获取透视变换矩阵
M = cv2.getPerspectiveTransform(p1, p2)

# 使用 warpPerspective 函数对原图进行透视变换
img_warp = cv2.warpPerspective(img, M, (img.shape[1], img.shape[0]))

# 显示原图和透视变换后的图像
cv2.imshow("img", img)
cv2.imshow('img_warp', img_warp)
cv2.waitKey(0)

题目5：

请编写一段Python代码，使用OpenCV库对一张图像进行以下处理：

1. 将图像转换为灰度图。
2. 使用高斯滤波器平滑图像，内核大小为5x5，标准差为1。
3. 使用Canny边缘检测算法检测图像边缘，阈值1为50，阈值2为150。
4. 在检测到的边缘图像上绘制轮廓，轮廓颜色为红色，厚度为2。

import cv2

# 读取名为 '12.png'的图片文件，这里的路径是相对于当前运行的脚本所在的路径的
img = cv2.imread('../day3/12.png')

# 将原图像从 BGR (Blue Green Red) 颜色空间转换到灰度空间
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 使用高斯滤波器进行模糊处理，以消除噪声。其中，(5, 5) 是高斯核的大小，1 是高斯核的标准差
img_blur = cv2.GaussianBlur(img_gray, (5, 5), 1)

# 对模糊后的图像进行 Canny 边缘检测，这一步是确定图像中边缘的重要步骤
img_canny = cv2.Canny(img_blur, 50, 150)

# 通过传入已经进行了边缘检测的图像 `img_canny` 寻找轮廓，然后在二值化图像中，找到白色部分的轮廓
# `cv2.RETR_EXTERNAL` 是检测方式，只寻找最外围的轮廓
# `cv2.CHAIN_APPROX_SIMPLE` 是轮廓近似方法，这里表示只提取轮廓的端点
img_contours, _ = cv2.findContours(img_canny, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 在原图上绘制找到的轮廓。-1 表示绘制所有轮廓，(0,0,255) 是 BGR 颜色，表示用红色进行绘制， 2 是线条的粗细
img_draw = cv2.drawContours(img, img_contours, -1, (0, 0, 255), 2)

# 显示处理后的图像
cv2.imshow('img', img)
cv2.waitKey(0)

题目6，交通信号灯识别‌：

你正在开发一个自动驾驶系统，需要识别交通信号灯的颜色（红、黄、绿）。请设计一个简化的流程，说明如何使用OpenCV来识别交通信号灯的颜色。

思路分析‌：

1. 读取包含交通信号灯的图像。
2. 转换图像到HSV颜色空间。
3. 分别为红、黄、绿三种颜色定义HSV范围，并创建三个掩膜。
4. 对每个掩膜进行轮廓检测，识别出可能的信号灯区域。

import cv2
import numpy as np

# 读取图片 '1.png'
img = cv2.imread('1.png')

# 将原图片从BGR颜色空间转换为HSV颜色空间
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# 按照HSV颜色空间中黄色的范围创建掩膜
hsv_min = np.array([26, 43, 46])
hsv_max = np.array([34, 255, 255])
img_mask_y = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 按照HSV颜色空间中绿色的范围创建掩膜
hsv_min = np.array([35, 43, 46])
hsv_max = np.array([77, 255, 255])
img_mask_green = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 按照HSV颜色空间中红色的范围创建两个掩膜，然后合并
hsv_min1 = np.array([0, 43, 46])
hsv_max1 = np.array([10, 255, 255])
hsv_min2 = np.array([156, 43, 46])
hsv_max2 = np.array([180, 255, 255])
img_mask_r1 = cv2.inRange(img_hsv, hsv_min1, hsv_max1)
img_mask_r2 = cv2.inRange(img_hsv, hsv_min2, hsv_max2)
img_mask_r = cv2.bitwise_or(img_mask_r2, img_mask_r1)

# 将黄色、绿色和红色的掩膜进行或运算，使这三个颜色区域的掩膜合并
img_mask_r = cv2.bitwise_or(img_mask_r, img_mask_y)
img_mask_r = cv2.bitwise_or(img_mask_r, img_mask_green)

# 在原图上使用掩膜，让其他颜色的区域为黑色，只保留红、黄、绿三色
img_mask_toil = cv2.bitwise_and(img, img, mask=img_mask_r)

# 使用高斯锐化处理掩膜后的图像，把图像转换为灰度，然后进行阈值处理，得到二值图
img_blur = cv2.GaussianBlur(img_mask_toil, (5, 5), 0)
img_gray = cv2.cvtColor(img_blur, cv2.COLOR_BGR2GRAY)
_, th = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# 查找二值图的轮廓，得到轮廓列表
contours, _ = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
img_copy = img.copy()

# 遍历轮廓列表，忽略掉面积太小的轮廓，对每个轮廓在原图上绘制矩形框
for i in contours:
    area = cv2.contourArea(i)
    if area < 2000:
        continue
    (x, y), d = cv2.minEnclosingCircle(i)
    center = (int(x), int(y))
    radius = int(d)
    cv2.circle(img, center, radius, (255, 0, 255), 2)

# 在复制的图片上绘制找到的所有轮廓
cv2.drawContours(img_copy, contours, -1, (0, 255, 0), 2)

# 显示处理后的图片
cv2.imshow('img_hsv_r', img)
cv2.waitKey(0)

在一家生产彩色玩具的工厂中，需要检测产品是否按照正确的颜色进行生产。请设计一个使用OpenCV的自动化检测系统，该系统能够识别并报告不符合颜色标准的产品。

‌思路分析‌：

1. 设定产品的标准颜色范围（HSV值）。
2. 使用摄像头或图像文件获取待检测产品的图像。
3. 转换图像到HSV颜色空间。
4. 为每种标准颜色创建掩膜，并与产品图像进行比对。
5. 识别出颜色不符合标准的产品，并记录或报告。

import cv2
import numpy as np

# 读取产品图片 'duck.png'
img = cv2.imread('duck.png')

# 将原图片从BGR颜色空间转换为HSV颜色空间
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)

# 按照HSV颜色空间中黄色的范围创建掩膜
hsv_min = np.array([26, 43, 46])
hsv_max = np.array([34, 255, 255])
img_mask_y = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 按照HSV颜色空间中白色的范围创建掩膜
hsv_min = np.array([0, 0, 221])
hsv_max = np.array([180, 30, 255])
img_mask_w = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 按照HSV颜色空间中橙色的范围创建掩膜
hsv_min = np.array([11, 43, 46])
hsv_max = np.array([25, 255, 255])
img_mask_orange = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 将黄色和白色的掩膜进行或运算，使这两个颜色区域的掩膜合并
img_mask_r = cv2.bitwise_or(img_mask_w, img_mask_y)
img_mask_r = cv2.bitwise_or(img_mask_r, img_mask_orange)
# 使用bitwise_not函数，得到的结果中，黄色和白色区域为黑色，其他颜色区域为白色
img_mask_and = cv2.bitwise_not(img_mask_r)

# 在原图和掩膜上进行"与"操作，保留其他颜色区域，黄色和白色区域黑色
img_toil = cv2.bitwise_and(img, img, mask=img_mask_and)
# 使用高斯锐化处理掩膜后的图像，把图像转换为灰度，然后进行阈值处理，得到二值图
img_blur = cv2.GaussianBlur(img_toil, (5, 5), 0)
img_gray = cv2.cvtColor(img_blur, cv2.COLOR_BGR2GRAY)

_, th = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

# 基于色块区域提取轮廓
contours, _ = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 在原始图像上绘制轮廓
for contour in contours:
    # 可以通过设置面积阈值来忽略小颜色块
    if cv2.contourArea(contour) > 4000:
        cv2.drawContours(img, [contour], -1, (0, 0, 255), 2)

# 显示处理后的图片
cv2.imshow('Detected Objects', img)
cv2.waitKey(0)

图像预处理与特征提取‌

1. 将图像转换为灰度图
2. 对灰度图进行二值化处理
3. 使用形态学变换去除噪声【开运算】
4. 检测图像中的边缘
5. 查找并绘制图像中的轮廓
6. 逐一遍历轮廓，输出所有四边形的周长 和 面积。

# 引入cv2和matplotlib.pyplot模块
import cv2
import matplotlib.pyplot as plt

# 使用cv2读取图像
img = cv2.imread('4.png')

# 对图像进行高斯模糊操作，使用3*3的核，标准差为1
img_blur = cv2.GaussianBlur(img, (3, 3), 1)

# 把模糊后的图像从BGR变为灰度图
img_gray = cv2.cvtColor(img_blur, cv2.COLOR_BGR2GRAY)

# 使用OSTU进行图像二值化，阈值设为127，二值化后小于阈值的部分设为255，大于设为0，反向输出
_, img_binary = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)

# 使用cv2找到二值化图像中的所有轮廓
contours, _ = cv2.findContours(img_binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 创建一个原图的副本
img_copy = img.copy()

# 遍历所有找到的轮廓
for i in contours:
    # 计算轮廓的矩
    m = cv2.moments(i)

    # 如果轮廓的面积（零阶矩）等于0，则继续下一轮循环
    if int(m['m00']) == 0:
        continue

    # 计算轮廓的周长
    arc_len = cv2.arcLength(i, True)

    # 使用Ramer-Douglas-Peucker算法找到轮廓的近似多边形
    approx = cv2.approxPolyDP(i, float(0.04) * arc_len, True)

    # 画出轮廓
    cv2.drawContours(img_copy, contours, -1, (0, 0, 0), 2)

    # 计算轮廓的重心
    cx = int(m['m10'] / m['m00'])
    cy = int(m['m01'] / m['m00'])

    # 判断多边形的形状
    if len(approx) == 3:
        square = 'triangle'
    elif len(approx) == 4:
        x, y, w, h = cv2.boundingRect(approx)
        ratio = w / h
        if ratio > 0.95 and ratio < 1.05:
            square = 'square'
        else:
            square = 'rectangle'
    elif len(approx) == 5:
        square = 'pentagon'
    else:
        square = 'circle'

    # 用文本标记出各个面积
    cv2.putText(img_copy, str(m['m00']), (cx, cy), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)

# 画出所有的轮廓
cv2.drawContours(img_copy, contours, -1, (0, 255, 0), 2)

# 显示处理后的图像
cv2.imshow('img', img_copy)
cv2.waitKey(0)

假设你正在开发一个车牌识别系统，首先需要从图像中识别出车牌区域。请描述并编写代码实现以下步骤：

1. 读取一张包含车牌的图像。
2. 将图像转换为灰度图以简化处理。
3. 使用高斯滤波器平滑图像，减少噪声干扰。
4. 应用Canny边缘检测算法检测图像中的边缘。
5. 查找图像中的轮廓。
6. 逐一遍历轮廓。
7. 设定一个面积双阈值，只保留面积在该阈值的轮廓。
8. 计算这些轮廓的长宽比，长宽比ratio在2到5.5之间的，在原图上用矩形框标出，这些轮廓可能是车牌的候选区域。

import cv2
import numpy as np

# 1. 读取图像
image = cv2.imread('img.png')  # 请确保路径正确
# 2. 转换为灰度图
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 3. 使用高斯滤波器平滑图像
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# 4. 应用Canny边缘检测
edges = cv2.Canny(blurred, 100, 200)

# 5. 查找图像中的轮廓
contours, _ = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 6. 遍历轮廓，进行筛选
for contour in contours:
    # 7. 设定面积双阈值，保留较大的轮廓
    if cv2.contourArea(contour) < 1000:  # 可调整这个值来过滤掉较小的轮廓
        continue

    # 8. 计算轮廓的矩形边界框
    x, y, w, h = cv2.boundingRect(contour)

    # 计算长宽比
    aspect_ratio = w / float(h)

    # 设定长宽比的阈值，筛选出符合车牌特征的矩形
    if 2 < aspect_ratio < 5.5:  # 车牌一般是长方形，长宽比通常在这个范围内
        # 画出轮廓
        cv2.drawContours(image, [contour], -1, (0, 255, 0), 3)  # 用绿色绘制轮廓

        # 在轮廓周围绘制矩形框
        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)  # 用红色矩形框标出车牌区域

# 9. 显示结果
cv2.imshow('Car Plate Detection', image)

# 按任意键关闭图像窗口
cv2.waitKey(0)
cv2.destroyAllWindows()